]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
This is the long awaited, long worked on, gorgeous patch implementing the whole 3d...
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 16 Feb 1999 17:14:05 +0000 (17:14 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 16 Feb 1999 17:14:05 +0000 (17:14 +0000)
git-svn-id: https://svn.dealii.org/trunk@817 0785d39b-7218-0410-832d-ea1e28bc413d

35 files changed:
deal.II/deal.II/include/dofs/dof_accessor.h
deal.II/deal.II/include/dofs/dof_handler.h
deal.II/deal.II/include/dofs/dof_levels.h
deal.II/deal.II/include/dofs/mg_dof_accessor.h
deal.II/deal.II/include/dofs/mg_dof_handler.h
deal.II/deal.II/include/fe/fe.h
deal.II/deal.II/include/fe/fe_lib.lagrange.h
deal.II/deal.II/include/fe/fe_linear_mapping.h
deal.II/deal.II/include/grid/geometry_info.h
deal.II/deal.II/include/grid/magic_numbers.h
deal.II/deal.II/include/grid/tria.h
deal.II/deal.II/include/grid/tria_accessor.h
deal.II/deal.II/include/grid/tria_iterator.h
deal.II/deal.II/include/grid/tria_quad.h
deal.II/deal.II/include/multigrid/mg_dof_accessor.h
deal.II/deal.II/include/multigrid/mg_dof_handler.h
deal.II/deal.II/source/Makefile
deal.II/deal.II/source/dofs/dof_accessor.cc
deal.II/deal.II/source/dofs/dof_constraints.cc
deal.II/deal.II/source/dofs/dof_handler.cc
deal.II/deal.II/source/fe/fe.cc
deal.II/deal.II/source/fe/fe_lib.cubic.cc
deal.II/deal.II/source/fe/fe_lib.linear.cc
deal.II/deal.II/source/fe/fe_lib.quadratic.cc
deal.II/deal.II/source/fe/fe_linear_mapping.cc
deal.II/deal.II/source/fe/fe_linear_mapping.jacobians.cc [new file with mode: 0644]
deal.II/deal.II/source/fe/scripts/2d/postprocess
deal.II/deal.II/source/fe/scripts/3d/lagrange-linear
deal.II/deal.II/source/fe/scripts/3d/lagrange-tools
deal.II/deal.II/source/fe/scripts/3d/postprocess
deal.II/deal.II/source/grid/tria.cc
deal.II/deal.II/source/grid/tria_accessor.cc
deal.II/deal.II/source/grid/tria_boundary.cc
deal.II/deal.II/source/numerics/base.cc
deal.II/deal.II/source/numerics/data_io.cc

index 1b977fc235503a304cd925f2c746f40007b31630..02da83439d9861b0f6985057333429994a70b6aa 100644 (file)
@@ -408,6 +408,137 @@ class DoFQuadAccessor :  public DoFAccessor<dim>, public BaseClass {
 
 
 
+/**
+ * Grant access to the degrees of freedom located on quads.
+ *
+ * @see DoFLineAccessor
+ */
+template <int dim, typename BaseClass>
+class DoFHexAccessor :  public DoFAccessor<dim>, public BaseClass {
+  public:
+                                    /**
+                                     * Declare the data type that this accessor
+                                     * class expects to get passed from the
+                                     * iterator classes.
+                                     */
+    typedef DoFHandler<dim> AccessorData;
+    
+                                    /**
+                                     * Default constructor, unused thus
+                                     * not implemented.
+                                     */
+    DoFHexAccessor ();
+
+                                    /**
+                                     * Constructor. The #local_data#
+                                     * argument is assumed to be a pointer
+                                     * to a #DoFHandler<dim># object.
+                                     */
+    DoFHexAccessor (Triangulation<dim> *tria,
+                   const int           level,
+                   const int           index,
+                   const AccessorData *local_data) :
+                   DoFAccessor<dim> (local_data),
+                   BaseClass        (tria,level,index) {};
+    
+                                    /**
+                                     * Return the index of the #i#th degree
+                                     * of freedom of this quad.
+                                     */
+    int dof_index (const unsigned int i) const;
+
+                                    /**
+                                     * Set the index of the #i#th degree
+                                     * of freedom of this quad to #index#.
+                                     */
+    void set_dof_index (const unsigned int i, const int index) const;
+
+                                    /**
+                                     * Return the index of the #i#th degree
+                                     * on the #vertex#th vertex.
+                                     */
+    int vertex_dof_index (const unsigned int vertex,
+                         const unsigned int i) const;
+
+                                    /**
+                                     * Set the index of the #i#th degree
+                                     * on the #vertex#th vertex to #index#.
+                                     */
+    void set_vertex_dof_index (const unsigned int vertex,
+                              const unsigned int i,
+                              const int          index) const;
+
+                                    /**
+                                     * Return the indices of the dofs of this
+                                     * quad in the standard ordering: dofs
+                                     * on vertex 0, dofs on vertex 1, etc,
+                                     * dofs on line 0, dofs on line 1, etc,
+                                     * dofs on quad 0, etc.
+                                     *
+                                     * It is assumed that the vector already
+                                     * has the right size beforehand.
+                                     */
+    void get_dof_indices (vector<int> &dof_indices) const;
+
+                                    /**
+                                     *  Return a pointer to the #i#th line
+                                     *  bounding this #Hex#.
+                                     */
+    TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
+    line (const unsigned int i) const;
+
+                                    /**
+                                     *  Return a pointer to the #i#th quad
+                                     *  bounding this #Hex#.
+                                     */
+    TriaIterator<dim,DoFQuadAccessor<dim,QuadAccessor<dim> > >
+    quad (const unsigned int i) const;
+    
+                                    /**
+                                     * Return the #i#th child as a DoF hex
+                                     * iterator. This function is needed since
+                                     * the child function of the base
+                                     * class returns a hex accessor without
+                                     * access to the DoF data.
+                                     */
+    TriaIterator<dim,DoFHexAccessor<dim,BaseClass> > child (const unsigned int) const;
+
+                                    /**
+                                     * Distribute a local (cell based) vector
+                                     * to a global one by mapping the local
+                                     * numbering of the degrees of freedom
+                                     * to the global one and entering the
+                                     * local values into the global vector.
+                                     *
+                                     * The elements are {\it added} up to
+                                     * the elements in the global vector,
+                                     * rather than just set, since this is
+                                     * usually what one wants.
+                                     */
+    void distribute_local_to_global (const dVector &local_source,
+                                    dVector       &global_destination) const;
+
+                                    /**
+                                     * This function does much the same as the
+                                     * #distribute_local_to_global(dVector,dVector)#
+                                     * function, but operates on matrices
+                                     * instead of vectors. The sparse matrix
+                                     * is supposed to have non-zero entry
+                                     * slots where required.
+                                     */
+    void distribute_local_to_global (const dFMatrix &local_source,
+                                    dSMatrix       &global_destination) const;
+    
+                                    /**
+                                     * Implement the copy operator needed
+                                     * for the iterator classes.
+                                     */
+    void copy_from (const DoFHexAccessor<dim,BaseClass> &a);
+};
+
+
+
+
 
 
 
@@ -503,6 +634,7 @@ class DoFSubstructAccessor<2> : public DoFQuadAccessor<2,CellAccessor<2> > {
                                      * iterator classes.
                                      */
     typedef typename DoFQuadAccessor<2,CellAccessor<2> >::AccessorData AccessorData;
+    
                                     /**
                                      * Constructor
                                      */
@@ -523,6 +655,41 @@ class DoFSubstructAccessor<2> : public DoFQuadAccessor<2,CellAccessor<2> > {
 
 
 
+/**
+ * Intermediate, "typedef"-class, not for public use.
+ *
+ * @see DoFSubstructAccessor<1>
+ */
+template <>
+class DoFSubstructAccessor<3> : public DoFHexAccessor<3,CellAccessor<3> > {
+  public:
+                                    /**
+                                     * Declare the data type that this accessor
+                                     * class expects to get passed from the
+                                     * iterator classes.
+                                     */
+    typedef typename DoFQuadAccessor<3,CellAccessor<3> >::AccessorData AccessorData;
+    
+                                    /**
+                                     * Constructor
+                                     */
+    DoFSubstructAccessor (Triangulation<3> *tria,
+                         const int         level,
+                         const int         index,
+                         const AccessorData *local_data) :
+                   DoFHexAccessor<3,CellAccessor<3> > (tria,level,index,local_data) {};
+                                    // do this here, since this way the
+                                    // CellAccessor has the possibility to know
+                                    // what a face_iterator is. Otherwise
+                                    // it would have to ask the DoFHandler<dim>
+                                    // which would need another big include
+                                    // file and maybe cyclic interdependence
+    typedef TriaIterator<3,DoFQuadAccessor<3,QuadAccessor<3> > > face_iterator;
+};
+
+
+
+
 
 
 /**
index 9c60d84c8589592e86bda6624d9586feda3604ea..7f260bf5139ed92810719c80e3cfc41bc78d7782 100644 (file)
 template <int dim> class TriaAccessor;
 template <int dim> class LineAccessor;
 template <int dim> class QuadAccessor;
+template <int dim> class HexAccessor;
 template <int dim> class CellAccessor;
 
 template <int dim, class BaseClass> class DoFLineAccessor;
 template <int dim, class BaseClass> class DoFQuadAccessor;
+template <int dim, class BaseClass> class DoFHexAccessor;
 template <int dim> class DoFCellAccessor;
 
 template <int dim> class DoFLevel;
@@ -73,6 +75,10 @@ class DoFDimensionInfo<1> {
     typedef void * quad_iterator;
     typedef void * active_quad_iterator;
 
+    typedef void * raw_hex_iterator;
+    typedef void * hex_iterator;
+    typedef void * active_hex_iterator;
+
     typedef raw_line_iterator    raw_cell_iterator;
     typedef line_iterator        cell_iterator;
     typedef active_line_iterator active_cell_iterator;
@@ -102,6 +108,10 @@ class DoFDimensionInfo<2> {
     typedef TriaIterator<2,DoFCellAccessor<2> >                  quad_iterator;
     typedef TriaActiveIterator<2,DoFCellAccessor<2> >            active_quad_iterator;
 
+    typedef void * raw_hex_iterator;
+    typedef void * hex_iterator;
+    typedef void * active_hex_iterator;
+
     typedef raw_quad_iterator    raw_cell_iterator;
     typedef quad_iterator        cell_iterator;
     typedef active_quad_iterator active_cell_iterator;
@@ -113,6 +123,36 @@ class DoFDimensionInfo<2> {
 
 
 
+/**
+ * Define some types for the DoF handling in two dimensions.
+ *
+ * The types have the same meaning as those declared in \Ref{TriaDimensionInfo<3>}.
+ */
+class DoFDimensionInfo<3> {
+  public:
+    typedef TriaRawIterator<3,DoFLineAccessor<3,LineAccessor<3> > >    raw_line_iterator;
+    typedef TriaIterator<3,DoFLineAccessor<3,LineAccessor<3> > >       line_iterator;
+    typedef TriaActiveIterator<3,DoFLineAccessor<3,LineAccessor<3> > > active_line_iterator;
+
+    typedef TriaRawIterator<3,DoFQuadAccessor<3,QuadAccessor<3> > >    raw_quad_iterator;
+    typedef TriaIterator<3,DoFQuadAccessor<3,QuadAccessor<3> > >       quad_iterator;
+    typedef TriaActiveIterator<3,DoFQuadAccessor<3,QuadAccessor<3> > > active_quad_iterator;
+
+    typedef TriaRawIterator<3,DoFCellAccessor<3> >               raw_hex_iterator;
+    typedef TriaIterator<3,DoFCellAccessor<3> >                  hex_iterator;
+    typedef TriaActiveIterator<3,DoFCellAccessor<3> >            active_hex_iterator;
+
+    typedef raw_hex_iterator    raw_cell_iterator;
+    typedef hex_iterator        cell_iterator;
+    typedef active_hex_iterator active_cell_iterator;
+
+    typedef raw_quad_iterator    raw_face_iterator;
+    typedef quad_iterator        face_iterator;
+    typedef active_quad_iterator active_face_iterator;    
+};
+
+
+
 
 
 
@@ -473,6 +513,10 @@ class DoFHandler : public DoFDimensionInfo<dim> {
     typedef typename DoFDimensionInfo<dim>::quad_iterator quad_iterator;
     typedef typename DoFDimensionInfo<dim>::active_quad_iterator active_quad_iterator;
 
+    typedef typename DoFDimensionInfo<dim>::raw_hex_iterator raw_hex_iterator;
+    typedef typename DoFDimensionInfo<dim>::hex_iterator hex_iterator;
+    typedef typename DoFDimensionInfo<dim>::active_hex_iterator active_hex_iterator;
+
     typedef typename DoFDimensionInfo<dim>::raw_cell_iterator raw_cell_iterator;
     typedef typename DoFDimensionInfo<dim>::cell_iterator cell_iterator;
     typedef typename DoFDimensionInfo<dim>::active_cell_iterator active_cell_iterator;
@@ -1268,6 +1312,113 @@ class DoFHandler : public DoFDimensionInfo<dim> {
 
                                     /*---------------------------------------*/
 
+                                    /**
+                                     *  @name Hex iterator functions*/
+                                    /*@{
+                                     */
+                                    /**
+                                     *  Return iterator to the first hex, used
+                                     *  or not, on level #level#. If a level
+                                     *  has no hexs, a past-the-end iterator
+                                     *  is returned.
+                                     */
+    raw_hex_iterator
+    begin_raw_hex   (const unsigned int level = 0) const;
+
+                                    /**
+                                     *  Return iterator to the first used hex
+                                     *  on level #level#.
+                                     */
+    hex_iterator
+    begin_hex       (const unsigned int level = 0) const;
+
+                                    /**
+                                     *  Return iterator to the first active
+                                     *  hex on level #level#.
+                                     */
+    active_hex_iterator
+    begin_active_hex(const unsigned int level = 0) const;
+
+                                    /**
+                                     *  Return iterator past the end; this
+                                     *  iterator serves for comparisons of
+                                     *  iterators with past-the-end or
+                                     *  before-the-beginning states.
+                                     */
+    raw_hex_iterator
+    end_hex () const;
+
+                                    /**
+                                     * Return an iterator which is the first
+                                     * iterator not on level. If #level# is
+                                     * the last level, then this returns
+                                     * #end()#.
+                                     */
+    hex_iterator        end_hex (const unsigned int level) const;
+    
+                                    /**
+                                     * Return a raw iterator which is the first
+                                     * iterator not on level. If #level# is
+                                     * the last level, then this returns
+                                     * #end()#.
+                                     */
+    raw_hex_iterator    end_raw_hex (const unsigned int level) const;
+
+                                    /**
+                                     * Return an active iterator which is the
+                                     * first iterator not on level. If #level#
+                                     * is the last level, then this returns
+                                     * #end()#.
+                                     */
+    active_hex_iterator end_active_hex (const unsigned int level) const;
+
+                                    /**
+                                     *  Return an iterator pointing to the
+                                     *  last hex, used or not.
+                                     */
+    raw_hex_iterator
+    last_raw_hex () const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  hex of the level #level#, used or not.
+
+                                     */
+    raw_hex_iterator
+    last_raw_hex (const unsigned int level) const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  used hex.
+                                     */
+    hex_iterator
+    last_hex () const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  used hex on level #level#.
+                                     */
+    hex_iterator
+    last_hex (const unsigned int level) const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  active hex.
+                                     */
+    active_hex_iterator
+    last_active_hex () const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  active hex on level #level#.
+                                     */
+    active_hex_iterator
+    last_active_hex (const unsigned int level) const;
+                                    /*@}*/
+
+                                    /*---------------------------------------*/
+
+
                                     /**
                                      * Return number of degrees of freedom.
                                      * Included in this number are those
@@ -1466,6 +1617,8 @@ class DoFHandler : public DoFDimensionInfo<dim> {
     friend class DoFLineAccessor<dim, CellAccessor<dim> >;
     friend class DoFQuadAccessor<dim, QuadAccessor<dim> >;
     friend class DoFQuadAccessor<dim, CellAccessor<dim> >;
+    friend class DoFHexAccessor<dim, HexAccessor<dim> >;
+    friend class DoFHexAccessor<dim, CellAccessor<dim> >;
 };
 
 
index 8682610f85d7a101f4d5b20f4d27772287c5bf62..e5b460d0b4f1984164ffe5ec62c0d0c940358662 100644 (file)
@@ -93,6 +93,22 @@ class DoFLevel<2> : public DoFLevel<1> {
 
 
 
+/**
+ * Store the indices of the degrees of freedom which are located on hexhedra.
+ * See \Ref{DoFLevel<1>} for more information.
+ */
+class DoFLevel<3> : public DoFLevel<2> {
+  public:
+                                    /**
+                                     * Store the global indices of the degrees
+                                     * of freedom. See \Ref{DoFLevel} for
+                                     * detailed information.
+                                     */
+    vector<int> hex_dofs;
+};
+
+
+
 /*----------------------------   dof_levels.h     ---------------------------*/
 /* end of #ifndef __dof_levels_H */
 #endif
index 37a6cfb5ee635fd6c7344dc364084169380e560f..0ee7b25e6bed867eff4452e1916f1114da4410d6 100644 (file)
@@ -333,6 +333,115 @@ class MGDoFQuadAccessor :  public MGDoFAccessor<dim>, public DoFQuadAccessor<dim
 
 
 
+/**
+ * Grant access to the multilevel degrees of freedom located on hexhedra.
+ *
+ * @see DoFLineAccessor
+ */
+template <int dim, typename BaseClass>
+class MGDoFHexAccessor :  public MGDoFAccessor<dim>, public DoFHexAccessor<dim, BaseClass> {
+  public:
+                                    /**
+                                     * Declare the data type that this accessor
+                                     * class expects to get passed from the
+                                     * iterator classes.
+                                     */
+    typedef MGDoFHandler<dim> AccessorData;
+
+                                    /**
+                                     * Default constructor, unused thus
+                                     * not implemented.
+                                     */
+    MGDoFHexAccessor ();
+
+                                    /**
+                                     * Constructor. The #local_data#
+                                     * argument is assumed to be a pointer
+                                     * to a #DoFHandler<dim># object.
+                                     */
+    MGDoFHexAccessor (Triangulation<dim> *tria,
+                     const int           level,
+                     const int           index,
+                     const AccessorData *local_data);
+    
+                                    /**
+                                     * Return the index of the #i#th degree
+                                     * of freedom of this hex on the level
+                                     * this quad lives on.
+                                     */
+    int mg_dof_index (const unsigned int i) const;
+
+                                    /**
+                                     * Set the index of the #i#th degree
+                                     * of freedom of this hex on the
+                                     * level this hex lives on to #index#.
+                                     */
+    void set_mg_dof_index (const unsigned int i, const int index) const;
+
+                                    /**
+                                     * Return the index of the #i#th degree
+                                     * on the #vertex#th vertex for the level
+                                     * this hex lives on.
+                                     */
+    int mg_vertex_dof_index (const unsigned int vertex,
+                            const unsigned int i) const;
+
+                                    /**
+                                     * Set the index of the #i#th degree
+                                     * on the #vertex#th vertex for the
+                                     * level this hex lives on to #index#.
+                                     */
+    void set_mg_vertex_dof_index (const unsigned int vertex,
+                                 const unsigned int i,
+                                 const int          index) const;
+
+                                    /**
+                                     * Return the indices of the dofs of this
+                                     * hex in the standard ordering: dofs
+                                     * on vertex 0, dofs on vertex 1, etc,
+                                     * dofs on line 0, dofs on line 1, etc,
+                                     * dofs on quad 0, etc.
+                                     *
+                                     * It is assumed that the vector already
+                                     * has the right size beforehand. The
+                                     * indices refer to the local numbering
+                                     * for the level this hex lives on.
+                                     */
+    void get_mg_dof_indices (vector<int> &dof_indices) const;
+
+                                    /**
+                                     * Return a pointer to the #i#th line
+                                     * bounding this #Hex#.
+                                     */
+    TriaIterator<dim,MGDoFLineAccessor<dim,LineAccessor<dim> > >
+    line (const unsigned int i) const;
+
+                                    /**
+                                     * Return a pointer to the #i#th quad
+                                     * bounding this #Hex#.
+                                     */
+    TriaIterator<dim,MGDoFLineAccessor<dim,QuadAccessor<dim> > >
+    quad (const unsigned int i) const;
+
+                                    /**
+                                     * Return the #i#th child as a DoF quad
+                                     * iterator. This function is needed since
+                                     * the child function of the base
+                                     * class returns a hex accessor without
+                                     * access to the DoF data.
+                                     */
+    TriaIterator<dim,MGDoFHexAccessor<dim,BaseClass> > child (const unsigned int) const;
+    
+                                    /**
+                                     * Implement the copy operator needed
+                                     * for the iterator classes.
+                                     */
+    void copy_from (const MGDoFHexAccessor<dim,BaseClass> &a);
+};
+
+
+
+
 
 /**
  * Intermediate, "typedef"-class, not for public use.
@@ -445,6 +554,40 @@ class MGDoFSubstructAccessor<2> : public MGDoFQuadAccessor<2,CellAccessor<2> > {
 
 
 
+/**
+ * Intermediate, "typedef"-class, not for public use.
+ *
+ * @see MGDoFSubstructAccessor<1>
+ */
+template <>
+class MGDoFSubstructAccessor<3> : public MGDoFHexAccessor<3,CellAccessor<3> > {
+  public:
+                                    /**
+                                     * Declare the data type that this accessor
+                                     * class expects to get passed from the
+                                     * iterator classes.
+                                     */
+    typedef MGDoFHexAccessor<3,CellAccessor<3> >::AccessorData AccessorData;
+    
+                                    /**
+                                     * Constructor
+                                     */
+    MGDoFSubstructAccessor (Triangulation<3> *tria,
+                           const int         level,
+                           const int         index,
+                           const AccessorData *local_data) :
+                   MGDoFHexAccessor<3,CellAccessor<3> > (tria,level,index,local_data) {};
+                                    // do this here, since this way the
+                                    // CellAccessor has the possibility to know
+                                    // what a face_iterator is. Otherwise
+                                    // it would have to ask the DoFHandler<dim>
+                                    // which would need another big include
+                                    // file and maybe cyclic interdependence
+    typedef TriaIterator<3,MGDoFQuadAccessor<3,QuadAccessor<3> > > face_iterator;
+};
+
+
+
 
 
 
index f5d5b1e958f7e701d5e131090a9b7fdbfe84a695..6f80e19be70741f35348e9d4d267e9266c8dc0d9 100644 (file)
@@ -47,6 +47,10 @@ class MGDoFDimensionInfo<1> {
     typedef void * quad_iterator;
     typedef void * active_quad_iterator;
 
+    typedef void * raw_hex_iterator;
+    typedef void * hex_iterator;
+    typedef void * active_hex_iterator;
+
     typedef raw_line_iterator    raw_cell_iterator;
     typedef line_iterator        cell_iterator;
     typedef active_line_iterator active_cell_iterator;
@@ -76,6 +80,10 @@ class MGDoFDimensionInfo<2> {
     typedef TriaIterator<2,MGDoFCellAccessor<2> >                  quad_iterator;
     typedef TriaActiveIterator<2,MGDoFCellAccessor<2> >            active_quad_iterator;
 
+    typedef void * raw_hex_iterator;
+    typedef void * hex_iterator;
+    typedef void * active_hex_iterator;
+
     typedef raw_quad_iterator    raw_cell_iterator;
     typedef quad_iterator        cell_iterator;
     typedef active_quad_iterator active_cell_iterator;
@@ -88,6 +96,37 @@ class MGDoFDimensionInfo<2> {
 
 
 
+/**
+ * Define some types for the DoF handling in two dimensions.
+ *
+ * The types have the same meaning as those declared in \Ref{TriaDimensionInfo<2>}.
+ */
+class MGDoFDimensionInfo<3> {
+  public:
+    typedef TriaRawIterator<3,MGDoFLineAccessor<3,LineAccessor<3> > >    raw_line_iterator;
+    typedef TriaIterator<3,MGDoFLineAccessor<3,LineAccessor<3> > >       line_iterator;
+    typedef TriaActiveIterator<3,MGDoFLineAccessor<3,LineAccessor<3> > > active_line_iterator;
+
+    typedef TriaRawIterator<3,MGDoFQuadAccessor<3,QuadAccessor<3> > >    raw_quad_iterator;
+    typedef TriaIterator<3,MGDoFQuadAccessor<3,QuadAccessor<3> > >       quad_iterator;
+    typedef TriaActiveIterator<3,MGDoFQuadAccessor<3,QuadAccessor<3> > > active_quad_iterator;
+
+    typedef TriaRawIterator<3,MGDoFCellAccessor<3> >               raw_hex_iterator;
+    typedef TriaIterator<3,MGDoFCellAccessor<3> >                  hex_iterator;
+    typedef TriaActiveIterator<3,MGDoFCellAccessor<3> >            active_hex_iterator;
+
+    typedef raw_hex_iterator    raw_cell_iterator;
+    typedef hex_iterator        cell_iterator;
+    typedef active_hex_iterator active_cell_iterator;
+
+    typedef raw_quad_iterator    raw_face_iterator;
+    typedef quad_iterator        face_iterator;
+    typedef active_quad_iterator active_face_iterator;    
+};
+
+
+
+
 
 template <int dim>
 class MGDoFHandler : public DoFHandler<dim> {
index 22ae8255644ca888ead029418793c645d7fdaac6..7d29d970579f18ddac4061d1c725c67536bc91b1 100644 (file)
@@ -147,7 +147,7 @@ class FiniteElementData
                                      * me why we have to declare and implement
                                      * this one explicitely.
                                      */
-    bool operator == (const FiniteElementData<2> &) const;
+    bool operator == (const FiniteElementData<dim> &) const;
 
                                     /**
                                      * Exception
@@ -472,7 +472,7 @@ class FiniteElementBase :
  * is needed in case two quads meet at a common line of which one is refined
  * once more than the other one. Then there are constraints referring to the
  * hanging nodes on that side of the line which is refined. These constraints
- * are represented by a $n\times m$-matrix #line_constraints#, where $n$ is the
+ * are represented by a $n\times m$-matrix #interface_constraints#, where $n$ is the
  * number of degrees of freedom on the refined side (those dofs on the middle
  * vertex plus those on the two lines), and $m$ is that of the unrefined side
  * (those dofs on the two vertices plus those on the line). The matrix is thus
@@ -498,6 +498,178 @@ class FiniteElementBase :
  * at the time of this writing whether this is a constraint itself.
  *
  *
+ * \subsection{Finite elements in three dimensions}
+ *
+ * For the interface constraints, almost the same holds as for the 2D case.
+ * The numbering for the indices $m$ on the mother face is obvious and keeps
+ * to the usual numbering of degrees of freedom on quadrilaterals.
+ *
+ * The numbering of the degrees of freedom on the interior of the refined
+ * faces for the index $n$ is as follows: let $d_v$ and $d_l$ be as above,
+ * and $d_q$ be the number of degrees of freedom per quadrilateral (and
+ * therefore per face), then $n=0...d_v-1$ denote the dofs on the vertex at
+ * the center, $n=d_v...5d_v-1$ for the dofs on the vertices at the center
+ * of the bounding lines of the quadrilateral,
+ * $n=5d_v..5d_v+4*d_l-1$ are for the degrees of freedom on
+ * the four lines connecting the center vertex to the outer boundary of the
+ * mother face, n=5d_v+4*d_l...5d_v+4*d_l+8*d_l-1# for the degrees of freedom
+ * on the small lines surrounding the quad,
+ * and $n=5d_v+12*d_l...5d_v+12*d_l+4*d_q-1$ for the dofs on the
+ * four child faces. Note the direction of the lines at the boundary of the
+ * quads, as shown below.
+ *
+ * The order of the twelve lines and the four child faces can be extracted
+ * from the following sketch, where the overall order of the different
+ * dof groups is depicted:
+ * \begin{verbatim}
+ *    *--13--3--14--*
+ *    |      |      |
+ *    16 20  7  19  12
+ *    |      |      |
+ *    4--8---0--6---2
+ *    |      |      |
+ *    15 17  5  18  11
+ *    |      |      |
+ *    *--9---1--10--*
+ * \end{verbatim}
+ * It should be noted that the face as shown here is in the standard form,
+ * i.e. with vertex zero at the bottom left, and the other vertices numbered
+ * counter clockwise. This explains the numbering of the lines labeled 13 and
+ * 14, as well as those labeled 15 and 16. The dofs on the lines need to
+ * be numbered in the direction of the lines, which is as follows:
+ * \begin{verbatim}
+ *    *-->---*-->---*
+ *    |      |      |
+ *    ^      ^      ^ 
+ *    |      |      |
+ *    *-->---*-->---*
+ *    |      |      |
+ *    ^      ^      ^ 
+ *    |      |      |
+ *    *-->---*-->---*
+ * \end{verbatim}
+ * The orientation of the quads should be obvious.
+ *
+ * The faces of a hexahedron are arranged in a way such that
+ * some must be viewed from the inside and some from the outside of the cell to
+ * show this order; refer to the documentation of the #Triangulation# class for
+ * the definition of this.
+ *
+ * If of the cells adjacent to one line more than one is refined and there is
+ * at least one unrefined cell, then the degrees of freedom on the refined line
+ * are constrained from two cells. For example, consider the cell behind the
+ * face shown above is refined, while the one in front of the face is not
+ * refined; then the dofs on the lines numbered 9 and 10 are constrained. If
+ * there are two more cells below the ones just introduced, with a common face
+ * right below the one shown, and of these is one refined and one unrefined one,
+ * then the degrees on the two mentioned small lines are constrained a second
+ * time. Since these constraints must be unique, it follows that the constraints
+ * for the degrees of freedom on refined lines may only be in terms of the
+ * degrees of freedom on the unrefined line, not in terms of the other
+ * degrees of freedom on a face.
+ *
+ * Since the handling of constraints on degrees of freedom is mostly done
+ * by the #ConstraintMatrix# class, this class checks whether the constraints
+ * introduced from the two sides are unique; it is able to handle the fact
+ * that the constraints for some of the dofs are entered more than once.
+ *
+ *
+ * \subsection{Notes on three space dimensions}
+ *
+ * In three space dimensions, using locally refined elements involves
+ * a difficulty not found in one or two spatial dimensions: the common
+ * face of two cells need not match exactly, if one of the cells is
+ * refined and the two cells are at the boundary. To understand this,
+ * look at the following sketch:
+ * \begin{verbatim}
+ *         *---------*---------*
+ *        /         /         /|
+ *       /         /         / |
+ *      /         /         /  |
+ *     *---------*---------*   |
+ *     |         |         |   |
+ *     |         |         |   *
+ *     |         |         |  /
+ *     |         |         | /
+ *     |         |         |/
+ *     *---------*---------*
+ * \end{verbatim}
+ *
+ * Assume the two top faces represent the boundary of the
+ * triangulation; assume further that the boundary of the original
+ * domain is curved here. Then, refining one of the two cells will
+ * lead to refinement of the top line of the common face of the two
+ * cells with the new mid-point being raised or lowered, i.e. the two
+ * children of this line will not take the same place as their mother
+ * line did (this is not properly drawable using only ASCII characters,
+ * use some imagination):
+ * \begin{verbatim}
+ *       ..*--.*---..*---------*
+ *      *----*----* /         /|
+ *      :    :    :/         / |
+ *     :    :    :/         /  |
+ *     *----*----*---------*   |
+ *     |    |    |         |   |
+ *     |    |    |         |   *
+ *     *----*----*         |  /
+ *     |    |    |         | /
+ *     |    |    |         |/
+ *     *----*----*---------*
+ * \end{verbatim}
+ * While this is the case with boundary faces in two spatial
+ * dimensions also, it here leads to the fact that the four child
+ * faces of the common face of the two cells will not coincide with
+ * their mother face as well.
+ *
+ * Before proceeding to the consequences of this, we should note that
+ * this problem occurs only for cells exactly at the boundary and if
+ * exactly one of the two cells is refined once. If one of the two is
+ * refined once and the other one twice, the problem again occurs only
+ * for the outermost layer of cells, not for the others.
+ *
+ * Now for the consequences. Because most finite elements, at least
+ * those implemented at present (February 1999) are implemented by
+ * interpolation to certain Lagrange points, and because the Lagrange
+ * points do not match, there is no easy way to obtain continuity or
+ * any other constraint on the finite element functions at this
+ * face. This is rather obvious since parts of the child faces of the
+ * left, refined cell do not match any face of the right, unrefined
+ * cell at all. This problem seems unsolvable using the usual finite
+ * elements with trial functions computed on the unit cell without
+ * taking into consideration the actual cell, so we do not even
+ * attempt to solve it.
+ *
+ * A second, but related problem comes into play when trying to
+ * compute integrals over faces which are refined from one side. For
+ * this problem, the #FESubfaceValues# class exists, and it evaluates
+ * certain functions of the finite element class involving the
+ * Jacobian determinant of the mapping of unit face to real face,
+ * restricted to a subface, and the normal vectors to the subfaces. We
+ * should note that here, we talk only about evaluating the finite
+ * element in the right cell, but on the common face; evaluating the
+ * finite element in the small cells on the left poses no problem. The
+ * question here is: what are the subfaces? It could either be the
+ * four subfaces of the refined cell to the left, or the four subfaces
+ * of the large face if it were refined with no curved boundary being
+ * near it. In the first case, points where we evaluate jacobians as
+ * well as normal vectors would match from both sides of the faces;
+ * however, the points at which the finite element function is
+ * evaluated, would not match, which needs to be that way because for
+ * some points of the small faces of the left cell there are no
+ * matching points on the right.
+ *
+ * The other possibility would be to totally ignore the existence of
+ * the boundary and evaluate the finite element in the right cell at
+ * subfaces which would be generated if the new vertex of the top line
+ * of the common face was the midpoint of the line. This approach is
+ * simpler from the implementational view point, but is also more
+ * appropriate, since we evaluate on the right cell and do not want to
+ * let this evaluation depend on the state of the left cell or its
+ * children.
+ *
+ * Within this library, the present implementation uses the second way.
+ *
+ *
  * \subsection{Notes on extending the finite element library}
  *
  * The #deal.II# library was mainly made to use lagrange elements of arbitrary
@@ -1110,6 +1282,33 @@ class FiniteElement : public FiniteElementBase<dim> {
                                      * contents of the matrix, so it need not
                                      * be necessary to clear the matrix before
                                      * use with this function.
+                                     *
+                                     * Some finite elements, especially in
+                                     * higher dimensions, may chose not to
+                                     * implement this function because the
+                                     * computational effort is growing
+                                     * rapidly, for the in-time computation
+                                     * of the matrix as well as for the
+                                     * setting up using a script. For
+                                     * example, the size of the generated
+                                     * #C++# code for the local mass
+                                     * matrix in 3d is 4.383.656 bytes
+                                     * already for the trilinear element.
+                                     * Higher order elements would
+                                     * produce even larger code.
+                                     *
+                                     * In the case of a finite element chosing
+                                     * not to implement the functionality of
+                                     * this function, that function is supposed
+                                     * to throw an exception of class
+                                     * #ExcComputationNotUseful# declared
+                                     * in this class, for example through the
+                                     * #AssertThrow# mechanism; you can catch
+                                     * this exception and compute the mass matrix
+                                     * by quadrature instead. Finite element
+                                     * classes not implementing this function
+                                     * are assumed to state this in their
+                                     * documentation.
                                      */
     virtual void get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
                                        const Boundary<dim> &boundary, 
@@ -1131,6 +1330,14 @@ class FiniteElement : public FiniteElementBase<dim> {
                                      * Exception
                                      */
     DeclException0 (ExcJacobiDeterminantHasWrongSign);
+                                    /**
+                                     * Exception
+                                     */
+    DeclException1 (ExcComputationNotUseful,
+                   int,
+                   << "The computation you required from this function is not "
+                   << "feasable or not probable in the present dimension ("
+                   << arg1 << ") because it would be prohibitively expensive.");
 };
 
 template <int dim>
index c44d72be0579c2d2664eaa20c561a5da7a1da7e7..9842e8d8543507dfb01b53cc9e921a7ed2e25017 100644 (file)
  * with the $j$th corner point, on the unit cell at point $\vec \xi$. The sum
  * over $j$ runs over all corner points.
  *
- * @author Wolfgang Bangerth, 1998
+ * The number of degrees of freedom equal the number of the respective vertex
+ * of the cell
+ *
+ * @author Wolfgang Bangerth, 1998, 1999
  */
 
 template <int dim>
@@ -95,6 +98,15 @@ class FELinear : public FELinearMapping<dim> {
                                     /**
                                      * Refer to the base class for detailed
                                      * information on this function.
+                                     *
+                                     * Please note that as allowed in the
+                                     * documentation of the base class,
+                                     * this function does not implement
+                                     * the setting up of the local mass
+                                     * matrix in three space dimensions
+                                     * because of too high computational
+                                     * costs. The specified exception
+                                     * is thrown instead.
                                      */
     virtual void get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
                                        const Boundary<dim> &boundary,
@@ -121,7 +133,82 @@ class FELinear : public FELinearMapping<dim> {
  * A linear (subparametric) mapping from the unit cell
  * to the real cell is implemented.
  *
- * @author Wolfgang Bangerth, 1998
+ * The numbering of the degrees of freedom is as follows:
+ * \begin{itemize}
+ * \item 1D case:
+ *   \begin{verbatim}
+ *      0---2---1
+ *   \end{verbatim}
+ *
+ * \item 2D case:
+ *   \begin{verbatim}
+ *      3---6---2
+ *      |       |
+ *      7   8   5
+ *      |       |
+ *      0---4---1
+ *   \end{verbatim}
+ *
+ * \item 3D case:
+ *   \begin{verbatim}
+ *         7--14---6        7--14---6
+ *        /|       |       /       /|
+ *      19 |       13     19      1813
+ *      /  15      |     /       /  |
+ *     3   |       |    3---10--2   |
+ *     |   4--12---5    |       |   5
+ *     |  /       /     |       9  /
+ *    11 16      17     11      | 17
+ *     |/       /       |       |/
+ *     0---8---1        0---8---1
+ *
+ *         *-------*        *-------*
+ *        /|       |       /       /|
+ *       / |  21   |      /  24   / |
+ *      /  |       |     /       /  |
+ *     *   |       |    *-------*   |
+ *     |25 *-------*    |       |23 *
+ *     |  /       /     |   20  |  /
+ *     | /  22   /      |       | /
+ *     |/       /       |       |/
+ *     *-------*        *-------* 
+ *   \end{verbatim}
+ *   The center vertex has number 26.
+ *
+ *   The respective coordinate values of the support points of the degrees
+ *   of freedom are as follows:
+ *   \begin{itemize}
+ *   \item Index 0: #[0, 0, 0]#;
+ *   \item Index 1: #[1, 0, 0]#;
+ *   \item Index 2: #[1, 0, 1]#;
+ *   \item Index 3: #[0, 0, 1]#;
+ *   \item Index 4: #[0, 1, 0]#;
+ *   \item Index 5: #[1, 1, 0]#;
+ *   \item Index 6: #[1, 1, 1]#;
+ *   \item Index 7: #[0, 1, 1]#;
+ *   \item Index 8: #[1/2, 0, 0]#;
+ *   \item Index 9: #[1, 0, 1/2]#;
+ *   \item Index 10: # [1/2, 0, 1]#;
+ *   \item Index 11: # [0, 0, 1/2]#;
+ *   \item Index 12: # [1/2, 1, 0]#;
+ *   \item Index 13: # [1, 1, 1/2]#;
+ *   \item Index 14: # [1/2, 1, 1]#;
+ *   \item Index 15: # [0, 1, 1/2]#;
+ *   \item Index 16: # [0, 1/2, 0]#;
+ *   \item Index 17: # [1, 1/2, 0]#;
+ *   \item Index 18: # [1, 1/2, 1]#;
+ *   \item Index 19: # [0, 1/2, 1]#;
+ *   \item Index 20: # [1/2, 0, 1/2]#;
+ *   \item Index 21: # [1/2, 1, 1/2]#;
+ *   \item Index 22: # [1/2, 1/2, 0]#;
+ *   \item Index 23: # [1, 1/2, 1/2]#;
+ *   \item Index 24: # [1/2, 1/2, 1]#;
+ *   \item Index 25: # [0, 1/2, 1/2]#;
+ *   \item Index 26: # [1/2, 1/2, 1/2]#; 
+ *   \end{itemize}
+ * \end{itemize}
+ *
+ * @author Wolfgang Bangerth, 1998, 1999
  */
 template <int dim>
 class FEQuadraticSub : public FELinearMapping<dim> {
@@ -192,6 +279,15 @@ class FEQuadraticSub : public FELinearMapping<dim> {
                                     /**
                                      * Refer to the base class for detailed
                                      * information on this function.
+                                     *
+                                     * Please note that as allowed in the
+                                     * documentation of the base class,
+                                     * this function does not implement
+                                     * the setting up of the local mass
+                                     * matrix in three space dimensions
+                                     * because of too high computational
+                                     * costs. The specified exception
+                                     * is thrown instead.
                                      */
     virtual void get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
                                        const Boundary<dim> &boundary,
@@ -308,6 +404,15 @@ class FECubicSub : public FELinearMapping<dim> {
                                     /**
                                      * Refer to the base class for detailed
                                      * information on this function.
+                                     *
+                                     * Please note that as allowed in the
+                                     * documentation of the base class,
+                                     * this function does not implement
+                                     * the setting up of the local mass
+                                     * matrix in three space dimensions
+                                     * because of too high computational
+                                     * costs. The specified exception
+                                     * is thrown instead.
                                      */
     virtual void get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
                                        const Boundary<dim> &boundary,
@@ -424,7 +529,16 @@ class FEQuarticSub : public FELinearMapping<dim> {
 
                                     /**
                                      * Refer to the base class for detailed
-                                     * information on this function.
+                                     * information on what this function does.
+                                     *
+                                     * Please note that as allowed in the
+                                     * documentation of the base class,
+                                     * this function does not implement
+                                     * the setting up of the local mass
+                                     * matrix in three space dimensions
+                                     * because of too high computational
+                                     * costs. The specified exception
+                                     * is thrown instead.
                                      */
     virtual void get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
                                        const Boundary<dim> &boundary,
index 4a489b7aba91a52c7d3efd374ead600e522dc5dd..b9001fb258a625a6b3d13fb915cd6deb894b198f 100644 (file)
@@ -25,11 +25,15 @@ class FELinearMapping : public FiniteElement<dim> {
                                      * Constructor. Simply passes through
                                      * its arguments to the base class. For
                                      * one space dimension, #dofs_per_quad#
+                                     * shall be zero; similarly, for one and
+                                     * two space dimensions, #dofs_per_hex#
                                      * shall be zero.
                                      */
     FELinearMapping (const unsigned int dofs_per_vertex,
                     const unsigned int dofs_per_line,
-                    const unsigned int dofs_per_quad=0);
+                    const unsigned int dofs_per_quad=0,
+                    const unsigned int dofs_per_hex =0,
+                    const unsigned int n_components =1);
 
                                     /**
                                      * Return the value of the #i#th shape
@@ -146,6 +150,31 @@ class FELinearMapping : public FiniteElement<dim> {
                                 const vector<vector<Tensor<1,dim> > > &shape_grad_transform,
                                 const Boundary<dim> &boundary) const;
 
+                                    /**
+                                     * Compute the jacobian matrices
+                                     * of the mapping between unit
+                                     * and real cell at the given
+                                     * points on the unit cell.
+                                     */
+    static void compute_jacobian_matrices (const DoFHandler<dim>::cell_iterator &cell,
+                                          const vector<Point<dim> >            &unit_points,
+                                          vector<Tensor<2,dim> >               &jacobians);
+
+                                    /**
+                                     * Compute the gradients of the jacobian
+                                     * matrices of the mapping between unit
+                                     * and real cell at the given
+                                     * points on the unit cell.
+                                     */
+    static void compute_jacobian_gradients (const DoFHandler<dim>::cell_iterator &cell,
+                                           const vector<Point<dim> >            &unit_points,
+                                           vector<Tensor<3,dim> >               &jacobians);
+
+
+                                    /**
+                                     * Exception
+                                     */
+    DeclException0 (ExcInternalError);
                                     /**
                                      * Exception
                                      */
index cfcaf9d4ef383c313c50822d4f199b5691e7454c..0be10a79d3b32fa87f8d1c1fd11a7b1ed97edbb6 100644 (file)
@@ -90,7 +90,7 @@ struct GeometryInfo
                                      *
                                      * 1. Duplicated it in the new coordinate direction.
                                      *
-                                     * 2. Connect all corrsponding
+                                     * 2. Connect all corresponding
                                      * vertices of the original
                                      * hypercube and the copy by
                                      * lines.
@@ -150,6 +150,11 @@ struct GeometryInfo
                                      * are (ordered in the direction of the
                                      * face) 0 and 1, on face 2 they are
                                      * 3 and 2, etc.
+                                     *
+                                     * For three spatial dimensions,
+                                     * the exact order of the children is
+                                     * laid down in the documentation of
+                                     * the #Triangulation# class.
                                      */
     static unsigned int child_cell_on_face (unsigned int face,
                                            unsigned int subface);
@@ -184,13 +189,22 @@ GeometryInfo<2>::child_cell_on_face (const unsigned int face,
 
 
 template<>
-inline unsigned int
-GeometryInfo<3>::child_cell_on_face (const unsigned int,
-                                    const unsigned int)
-{
-  Assert(false, ExcNotImplemented());
-  return 0;
-}
+inline
+unsigned int GeometryInfo<3>::child_cell_on_face (const unsigned int face,
+                                                 const unsigned int subface) {
+  Assert (face<faces_per_cell, ExcInvalidIndex(face,faces_per_cell));
+  Assert (subface<subfaces_per_face, ExcInvalidIndex(subface,subfaces_per_face));
+  
+  static const unsigned subcells[faces_per_cell][subfaces_per_face] = {{0, 1, 2, 3},
+                                                                      {4, 5, 6, 7},
+                                                                      {0, 1, 5, 4},
+                                                                      {1, 5, 6, 2},
+                                                                      {3, 2, 6, 7},
+                                                                      {0, 4, 7, 3}};
+  return subcells[face][subface];
+};
+
+
 
 /*----------------------------   geometry_info.h     ---------------------------*/
 /* end of #ifndef __geometry_info_H */
index 23b5ce6188d55d53c116e3cfd652c20b88e469db..07abdee7c340c7cf3291be522b3654f5ea760fab 100644 (file)
@@ -20,6 +20,8 @@ const unsigned int mn_tria_line_user_flags_begin = 0xa100;
 const unsigned int mn_tria_line_user_flags_end   = 0xa101;
 const unsigned int mn_tria_quad_user_flags_begin = 0xa110;
 const unsigned int mn_tria_quad_user_flags_end   = 0xa111;
+const unsigned int mn_tria_hex_user_flags_begin  = 0xa112;
+const unsigned int mn_tria_hex_user_flags_end    = 0xa113;
 
 
 
index d5542986dd506223a061f1ff4294c1d952b52ac0..1e2165fff29d435e72d1bdbdffbabf82c20e4de0 100644 (file)
@@ -17,6 +17,7 @@ template <int dim> class Boundary;
 template <int dim> class TriaAccessor;
 template <int dim> class LineAccessor;
 template <int dim> class QuadAccessor;
+template <int dim> class HexAccessor;
 template <int dim> class CellAccessor;
 
 template <int dim> class TriangulationLevel;
@@ -28,9 +29,6 @@ template <int dim, class Accessor> class TriaActiveIterator;
 template <int dim> class DoFHandler;
 template <int dim> class MGDoFHandler;
 
-template <int dim> struct CellData;
-struct SubCellData;
-
 class dVector;
 
 
@@ -163,6 +161,7 @@ class TriaDimensionInfo;
 
 /**
  *  This class implements some types which differ between the dimensions.
+ *  These are the declararions for the 1D case only.
  *
  *  A #line_iterator# is typdef'd to an iterator operating on the
  *  #lines# member variable of a #Triangulation<1># object. An
@@ -179,7 +178,8 @@ class TriaDimensionInfo;
  *  To enable the declaration of #begin_quad# and the like in
  *  #Triangulation<1>#, the #quad_iterator#s are declared as
  *  #void *#. Thus these types exist, but are useless and will
- *  certainly make any involuntary use visible.
+ *  certainly make any involuntary use visible. The same holds
+ *  for hexahedron iterators.
  *
  *  The same applies for the #face_iterator# types, since lines
  *  have no substructures apart from vertices, which are handled in
@@ -196,6 +196,10 @@ class TriaDimensionInfo<1> {
     typedef void * quad_iterator;
     typedef void * active_quad_iterator;
 
+    typedef void * raw_hex_iterator;
+    typedef void * hex_iterator;
+    typedef void * active_hex_iterator;
+
     typedef raw_line_iterator    raw_cell_iterator;
     typedef line_iterator        cell_iterator;
     typedef active_line_iterator active_cell_iterator;
@@ -208,19 +212,25 @@ class TriaDimensionInfo<1> {
 
 /**
  *  This class implements some types which differ between the dimensions.
+ *  These are the declararions for the 2D case only.
  *
  *  A #line_iterator# is typdef'd to an iterator operating on the
- *  #lines# member variable of a #Triangulation<1># object. An
+ *  #lines# member variable of a #Triangulation<2># object. An
  *  #active_line_iterator# only operates on the active lines.
  *  #raw_line_iterator# objects operate on all lines, used or not.
- *  Using #active_line_iterator#s may not be particularly useful since it
+ *  Using #active_line_iterator#s may not be particularly in 2D useful since it
  *  only operates on unrefined lines. However, also refined lines may bound
  *  unrefined cells if the neighboring cell is refined once more than the
  *  present one.
  *
- *  Similarly, #quad_iterator#, #raw_quad_iterator# and
+ *  Similarly to line iterators, #quad_iterator#, #raw_quad_iterator# and
  *  #active_quad_iterator# are declared.
  *  
+ *  To enable the declaration of #begin_hex# and the like in
+ *  #Triangulation<[12]>#, the #hex_iterator#s are declared as
+ *  #void *#. Thus these types exist, but are useless and will
+ *  certainly make any involuntary use visible.
+ *
  *  Since we are in two dimension, the following identities are declared:
  *  \begin{verbatim}
  *    typedef raw_quad_iterator    raw_cell_iterator;
@@ -243,6 +253,10 @@ class TriaDimensionInfo<2> {
     typedef TriaIterator<2,CellAccessor<2> >       quad_iterator;
     typedef TriaActiveIterator<2,CellAccessor<2> > active_quad_iterator;
 
+    typedef void * raw_hex_iterator;
+    typedef void * hex_iterator;
+    typedef void * active_hex_iterator;
+
     typedef raw_quad_iterator    raw_cell_iterator;
     typedef quad_iterator        cell_iterator;
     typedef active_quad_iterator active_cell_iterator;
@@ -255,6 +269,47 @@ class TriaDimensionInfo<2> {
 
 
 
+/**
+ *  This class implements some types which differ between the dimensions.
+ *  These are the declararions for the 3D case only.
+ *
+ *  For the declarations of the data types, more or less the same holds
+ *  as for lower dimensions (see #TriaDimensionInfo<[12]>#). The
+ *  dimension specific data types are here, since we are in three dimensions:
+ *  \begin{verbatim}
+ *    typedef raw_hex_iterator    raw_cell_iterator;
+ *    typedef hex_iterator        cell_iterator;
+ *    typedef active_hex_iterator active_cell_iterator;
+ *
+ *    typedef raw_quad_iterator    raw_face_iterator;
+ *    typedef quad_iterator        face_iterator;
+ *    typedef active_quad_iterator active_face_iterator;    
+ *  \end{verbatim}
+ */
+template <>
+class TriaDimensionInfo<3> {
+  public:
+    typedef TriaRawIterator<3,LineAccessor<3> >    raw_line_iterator;
+    typedef TriaIterator<3,LineAccessor<3> >       line_iterator;
+    typedef TriaActiveIterator<3,LineAccessor<3> > active_line_iterator;
+    
+    typedef TriaRawIterator<3,QuadAccessor<3> >    raw_quad_iterator;
+    typedef TriaIterator<3,QuadAccessor<3> >       quad_iterator;
+    typedef TriaActiveIterator<3,QuadAccessor<3> > active_quad_iterator;
+
+    typedef TriaRawIterator<3,CellAccessor<3> >    raw_hex_iterator;
+    typedef TriaIterator<3,CellAccessor<3> >       hex_iterator;
+    typedef TriaActiveIterator<3,CellAccessor<3> > active_hex_iterator;
+
+    typedef raw_hex_iterator    raw_cell_iterator;
+    typedef hex_iterator        cell_iterator;
+    typedef active_hex_iterator active_cell_iterator;
+
+    typedef raw_quad_iterator    raw_face_iterator;
+    typedef quad_iterator        face_iterator;
+    typedef active_quad_iterator active_face_iterator;    
+};
+
 
 
 
@@ -1131,6 +1186,22 @@ class TriaDimensionInfo<2> {
  *   Similarly we define, that the four children of a quad are adjacent to the
  *   vertex with the same number of the old quad.
  *
+ *   \subsubsection{Coordinate systems}
+ *
+ *   When explicit coordinates are required for points in a cell (e.g for
+ *   quadrature formulae or the point of definition of trial functions), we
+ *   define the following coordinate system for the unit cell:
+ *   \begin{verbatim}
+ *    y^   3-------2
+ *     |   |       |
+ *     |   |       |
+ *     |   |       |
+ *     |   0-------1
+ *     *-------------->x
+ *   \end{verbatim}
+ *   with vertex 0 being the origin of the coordinate system, vertex 1 having
+ *   coordinates #(1,0)#, vertex 2 at #(1,1)# and vertex 3 at #(0,1)#.
+ *
  *
  *   \subsection{Implementational conventions for three spatial dimensions}
  *
@@ -1212,16 +1283,144 @@ class TriaDimensionInfo<2> {
  *   \begin{verbatim}
  *         *-------*        *-------*
  *        /|       |       /       /|
- *       / |   2   |      /  5    / |
+ *       / |   1   |      /   4   / |
  *      /  |       |     /       /  |
  *     *   |       |    *-------*   |
- *     | 6 *-------*    |       | 4 *
+ *     | 5 *-------*    |       | 3 *
  *     |  /       /     |       |  /
- *     | /   3   /      |   1   | /
+ *     | /   2   /      |   0   | /
  *     |/       /       |       |/
  *     *-------*        *-------*
  *   \end{verbatim}
  *
+ *   The direction of the faces is determined by the numbers the lines have within
+ *   a given face. This is like follows:
+ *   \begin{itemize}
+ *   \item Faces 0 and 1:
+ *    \begin{verbatim}
+ *          *---2---*        *-------*
+ *         /|       |       /       /|
+ *        / |       1      /       / |
+ *       /  3       |     /       /  |
+ *      *   |       |    *---2---*   |
+ *      |   *---0---*    |       |   *
+ *      |  /       /     |       1  /
+ *      | /       /      3       | /
+ *      |/       /       |       |/
+ *      *-------*        *---0---*
+ *    \end{verbatim}
+ * 
+ *   \item Faces 2 and 4:
+ *    \begin{verbatim}
+ *          *-------*        *---2---*
+ *         /|       |       /       /|
+ *        / |       |      3       1 |
+ *       /  |       |     /       /  |
+ *      *   |       |    *---0---*   |
+ *      |   *---2---*    |       |   *
+ *      |  /       /     |       |  /
+ *      | 3       1      |       | /
+ *      |/       /       |       |/
+ *      *---0---*        *-------*
+ *    \end{verbatim} 
+ * 
+ *   \item Faces 3 and 5:
+ *    \begin{verbatim}
+ *          *-------*        *-------*
+ *         /|       |       /       /|
+ *        2 1       |      /       2 1
+ *       /  |       |     /       /  |
+ *      *   |       |    *-------*   |
+ *      |   *-------*    |       |   *
+ *      3  /       /     |       3  /
+ *      | 0       /      |       | 0
+ *      |/       /       |       |/
+ *      *-------*        *-------*
+ *    \end{verbatim}
+ *   \end{itemize}
+ * 
+ *   Due to this numbering, the following lines are identical:
+ *   \begin{itemize}
+ *   \item Line 0 of face 0, and line 0 of face 2;
+ *   \item Line 1 of face 0, and line 3 of face 3;
+ *   \item Line 2 of face 0, and line 0 of face 4;
+ *   \item Line 3 of face 0, and line 3 of face 5;
+ *   \item Line 0 of face 1, and line 2 of face 2;
+ *   \item Line 1 of face 1, and line 1 of face 3;
+ *   \item Line 2 of face 1, and line 2 of face 4;
+ *   \item Line 3 of face 1, and line 1 of face 5;
+ *   \item Line 3 of face 2, and line 0 of face 5;
+ *   \item Line 1 of face 2, and line 0 of face 3;
+ *   \item Line 1 of face 4, and line 2 of face 3;
+ *   \item Line 3 of face 4, and line 2 of face 5.
+ *   \end{itemize}
+ *
+ *
+ *   \subsubsection{Children}
+ *
+ *   The eight children of a cell are numbered as follows:
+ *   \begin{verbatim}
+ *         *-------*        *-------*
+ *        /| 7   6 |       / 7   6 /|
+ *       /7|       |      /       /6|
+ *      /  |       |     / 3   2 /  |
+ *     *   | 4   5 |    *-------*2 5|
+ *     |3 4*-------*    | 3   2 |   *
+ *     |  / 4   5 /     |       |  /
+ *     |0/       /      |       |1/
+ *     |/0    1 /       | 0   1 |/
+ *     *-------*        *-------*
+ *   \end{verbatim}
+ *
+ *   Taking into account the orientation of the faces, the following
+ *   children are adjacent to the respective faces:
+ *   \begin{itemize}
+ *   \item Face 0: children 0, 1, 2, 3;
+ *   \item Face 1: children 4, 5, 6, 7;
+ *   \item Face 2: children 0, 1, 5, 4;
+ *   \item Face 3: children 1, 5, 6, 2;
+ *   \item Face 4: children 3, 2, 6, 7;
+ *   \item Face 5: children 0, 4, 7, 3.
+ *   \end{itemize}
+ *   You can get these numbers using the #GeometryInfo<3>::child_cell_on_face#
+ *   function. Each child is adjacent to the vertex with the same number.
+ *
+ *
+ *   \subsubsection{Coordinate systems}
+ *
+ *   We define the following coordinate system for the explicit coordinates of
+ *   the vertices of the unit cell:
+ *   \begin{verbatim}
+ *                         7-------6        7-------6
+ *                        /|       |       /       /|
+ *                       / |       |      /       / |
+ *    z                 /  |       |     /       /  |
+ *    ^                3   |       |    3-------2   |
+ *    |   ^y           |   4-------5    |       |   5
+ *    |  /             |  /       /     |       |  /
+ *    | /              | /       /      |       | /
+ *    |/               |/       /       |       |/
+ *    *------>x        0-------1        0-------1
+ *   \end{verbatim}
+ *   This convention in conjunction with the numbering of the vertices is a bit
+ *   unfortunate, since the vertices 0 through 3 have the coordinates #(x,0,z)#
+ *   with #x# and #z# being the same as the #x# and #y# coordinates of a quad
+ *   in the plane; more intuitive would have been if they had the coordinates
+ *   #(x,y,0)#. However, the vertex numbering was historically chosen as shown.
+ *
+ *   By the convention laid down as above, the vertices have the following
+ *   coordinates:
+ *   \begin{itemize}
+ *      \item Vertex 0: #(0,0,0)#;
+ *      \item Vertex 1: #(1,0,0)#;
+ *      \item Vertex 2: #(1,0,1)#;
+ *      \item Vertex 3: #(0,0,1)#;
+ *      \item Vertex 4: #(0,1,0)#;
+ *      \item Vertex 5: #(1,1,0)#;
+ *      \item Vertex 6: #(1,1,1)#;
+ *      \item Vertex 7: #(0,1,1)#.
+ *   \end{itemize}
+ *
  *
  *   \subsection{Warning}
  *
@@ -1237,9 +1436,6 @@ class TriaDimensionInfo<2> {
 template <int dim>
 class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
   public:
-                                    // insert these definitions for gcc2.8,
-                                    // since it can't inherit typedefs (I
-                                    // believe it should, but it can't)
     typedef typename TriaDimensionInfo<dim>::raw_line_iterator raw_line_iterator;
     typedef typename TriaDimensionInfo<dim>::line_iterator line_iterator;
     typedef typename TriaDimensionInfo<dim>::active_line_iterator active_line_iterator;
@@ -1248,6 +1444,10 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
     typedef typename TriaDimensionInfo<dim>::quad_iterator quad_iterator;
     typedef typename TriaDimensionInfo<dim>::active_quad_iterator active_quad_iterator;
 
+    typedef typename TriaDimensionInfo<dim>::raw_hex_iterator raw_hex_iterator;
+    typedef typename TriaDimensionInfo<dim>::hex_iterator hex_iterator;
+    typedef typename TriaDimensionInfo<dim>::active_hex_iterator active_hex_iterator;
+
     typedef typename TriaDimensionInfo<dim>::raw_cell_iterator raw_cell_iterator;
     typedef typename TriaDimensionInfo<dim>::cell_iterator cell_iterator;
     typedef typename TriaDimensionInfo<dim>::active_cell_iterator active_cell_iterator;
@@ -1294,7 +1494,10 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
                                      *  function, i.e. you have to make sure
                                      *  that it is not destroyed before
                                      *  #Triangulation<>::execute_refinement()#
-                                     *  is called the last time.
+                                     *  is called the last time. Checking this
+                                     *  is mostly done by the library by
+                                     *  using a #Subscriptor# object as base
+                                     *  class for boundary objects.
                                      *
                                      *  If you copy this triangulation to
                                      *  another one using the
@@ -1302,6 +1505,26 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
                                      *  make sure that the lifetime of boundary
                                      *  object extends to the lifetime of the
                                      *  new triangulation as well.
+                                     *
+                                     *  Because of the use of the #Subscriptor#
+                                     *  base class, you must wait for the
+                                     *  #Triangulation# object to release the
+                                     *  lock to the boundary object before
+                                     *  destroying that. This usually happens
+                                     *  when the destructor of the
+                                     *  triangulation is executed, but you may
+                                     *  manually do so by calling
+                                     *  #set_boundary(0)#, passing a Null
+                                     *  pointer as new boundary object. This
+                                     *  is the interpreted as "take the
+                                     *  default boundary object", which
+                                     *  actually is a #StraightBoundary#
+                                     *  object.
+                                     *
+                                     *  You are allowed to remove or replace
+                                     *  the boundary object during the lifetime
+                                     *  of a non-empty triangulation, but
+                                     *  you should be sure about what you do.
                                      */
     void set_boundary (const Boundary<dim> *boundary_object);
 
@@ -1524,7 +1747,10 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
                                      *  were previously flagged for refinement.
                                      *
                                      *  The function resets all refinement
-                                     *  flags to false.
+                                     *  flags to false. In three spatial
+                                     *  dimensions, the user flag is used
+                                     *  for lines and quads, but not for
+                                     *  cells.
                                      *
                                       *  See the general docs for more
                                       *  information.
@@ -1550,7 +1776,9 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
                                      *  doc of this class for more information.
                                      *
                                      *  This function is mostly dimension
-                                     *  independent.
+                                     *  independent. However, for some
+                                     *  dimension dependent things, it calls
+                                     *  #prepare_refinement_dim_dependent#.
                                      */
     bool prepare_refinement ();
 
@@ -1744,6 +1972,27 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
                                      * Load the user flags located on quads.
                                      */
     void load_user_flags_quad (const vector<bool> &v);
+
+                                    /**
+                                     * Save the user flags on hexs.
+                                     */
+    void save_user_flags_hex (ostream &out) const;
+
+                                    /**
+                                     * Same as above, but store the flags to
+                                     * a bitvector rather than to a file.
+                                     */
+    void save_user_flags_hex (vector<bool> &v) const;
+
+                                    /**
+                                     * Load the user flags located on hexs.
+                                     */
+    void load_user_flags_hex (istream &in);
+
+                                    /**
+                                     * Load the user flags located on hexs.
+                                     */
+    void load_user_flags_hex (const vector<bool> &v);
                                     /*@}*/
 
                                     /* ------------------------------------ */
@@ -2213,6 +2462,112 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
 
                                     /*---------------------------------------*/
 
+                                    /**
+                                     *  @name Hex iterator functions*/
+                                    /*@{
+                                     */
+                                    /**
+                                     *  Return iterator to the first hex, used
+                                     *  or not, on level #level#. If a level
+                                     *  has no hexs, a past-the-end iterator
+                                     *  is returned.
+                                     */
+    raw_hex_iterator
+    begin_raw_hex   (const unsigned int level = 0) const;
+
+                                    /**
+                                     *  Return iterator to the first used hex
+                                     *  on level #level#.
+                                     */
+    hex_iterator
+    begin_hex       (const unsigned int level = 0) const;
+
+                                    /**
+                                     *  Return iterator to the first active
+                                     *  hex on level #level#.
+                                     */
+    active_hex_iterator
+    begin_active_hex(const unsigned int level = 0) const;
+
+                                    /**
+                                     *  Return iterator past the end; this
+                                     *  iterator serves for comparisons of
+                                     *  iterators with past-the-end or
+                                     *  before-the-beginning states.
+                                     */
+    raw_hex_iterator
+    end_hex () const;
+
+                                    /**
+                                     * Return an iterator which is the first
+                                     * iterator not on level. If #level# is
+                                     * the last level, then this returns
+                                     * #end()#.
+                                     */
+    hex_iterator        end_hex (const unsigned int level) const;
+    
+                                    /**
+                                     * Return a raw iterator which is the first
+                                     * iterator not on level. If #level# is
+                                     * the last level, then this returns
+                                     * #end()#.
+                                     */
+    raw_hex_iterator    end_raw_hex (const unsigned int level) const;
+
+                                    /**
+                                     * Return an active iterator which is the
+                                     * first iterator not on level. If #level#
+                                     * is the last level, then this returns
+                                     * #end()#.
+                                     */
+    active_hex_iterator end_active_hex (const unsigned int level) const;
+
+                                    /**
+                                     *  Return an iterator pointing to the
+                                     *  last hex, used or not.
+                                     */
+    raw_hex_iterator
+    last_raw_hex () const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  hex of the level #level#, used or not.
+
+                                     */
+    raw_hex_iterator
+    last_raw_hex (const unsigned int level) const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  used hex.
+                                     */
+    hex_iterator
+    last_hex () const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  used hex on level #level#.
+                                     */
+    hex_iterator
+    last_hex (const unsigned int level) const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  active hex.
+                                     */
+    active_hex_iterator
+    last_active_hex () const;
+
+                                    /**
+                                     *  Return an iterator pointing to the last
+                                     *  active hex on level #level#.
+                                     */
+    active_hex_iterator
+    last_active_hex (const unsigned int level) const;
+                                    /*@}*/
+
+                                    /*---------------------------------------*/
+
                                     /**
                                      *  @name Input/Output functions
                                      */
@@ -2291,7 +2646,7 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
                                      * for the #n_cells()# function.
                                      */
     unsigned int n_quads () const;
-    
+
                                     /**
                                      *  Return total number of used quads,
                                      *  active or not on level #level#.
@@ -2322,6 +2677,46 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
                                      */
     unsigned int n_active_quads (const unsigned int level) const;
     
+                                    /**
+                                     *  Return total number of used hexahedra,
+                                     *  active or not.
+                                     *
+                                     * Regarding the computational effort of
+                                     * this function, the same applies as
+                                     * for the #n_cells()# function.
+                                     */
+    unsigned int n_hexs() const;
+
+                                    /**
+                                     *  Return total number of used hexahedra,
+                                     *  active or not on level #level#.
+                                     *
+                                     * Regarding the computational effort of
+                                     * this function, the same applies as
+                                     * for the #n_cells()# function.
+                                     */
+    unsigned int n_hexs(const unsigned int level) const;
+    
+                                    /**
+                                     *  Return total number of active hexahedra,
+                                     *  active or not.
+                                     *
+                                     * Regarding the computational effort of
+                                     * this function, the same applies as
+                                     * for the #n_cells()# function.
+                                     */
+    unsigned int n_active_hexs() const;
+    
+                                    /**
+                                     *  Return total number of active hexahedra,
+                                     *  active or not on level #level#.
+                                     *
+                                     * Regarding the computational effort of
+                                     * this function, the same applies as
+                                     * for the #n_cells()# function.
+                                     */
+    unsigned int n_active_hexs(const unsigned int level) const;
+
                                     /**
                                      *  Return total number of used cells,
                                      *  active or not.
@@ -2564,6 +2959,26 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
                                      * of #execute_coarsening#.
                                      */
     void delete_cell (cell_iterator &cell);
+
+                                    /**
+                                     * Some dimension dependent stuff for
+                                     * mesh smoothing. This function returns
+                                     * whether some flags were changed.
+                                     *
+                                     * At present, this function does nothing
+                                     * in 1d and 2d, but makes sure no two
+                                     * cells with a level difference greater
+                                     * than one share one line in 3d. This
+                                     * is a requirement needed for the
+                                     * interpolation of hanging nodes, since
+                                     * otherwise to steps of interpolation
+                                     * would be necessary. This would make
+                                     * the processes implemented in the
+                                     * #ConstraintMatrix# class much more
+                                     * complex, since these two steps of
+                                     * interpolation do not commute.
+                                     */
+    bool prepare_refinement_dim_dependent ();
     
                                     /**
                                      *  Array of pointers pointing to the
@@ -2604,16 +3019,22 @@ class Triangulation : public TriaDimensionInfo<dim>, public Subscriptor {
     friend class TriaAccessor<dim>;
     friend class LineAccessor<dim>;
     friend class QuadAccessor<dim>;
+    friend class HexAccessor<dim>;
 
-    friend class CellAccessor<1>;
-    friend class CellAccessor<2>;
+    friend class CellAccessor<dim>;
     
     friend class TriaRawIterator<1,LineAccessor<1> >;
     friend class TriaRawIterator<1,CellAccessor<1> >;
+
     friend class TriaRawIterator<2,LineAccessor<2> >;
     friend class TriaRawIterator<2,QuadAccessor<2> >;
     friend class TriaRawIterator<2,CellAccessor<2> >;
 
+    friend class TriaRawIterator<3,LineAccessor<3> >;
+    friend class TriaRawIterator<3,QuadAccessor<3> >;
+    friend class TriaRawIterator<3,HexAccessor<3> >;
+    friend class TriaRawIterator<3,CellAccessor<3> >;
+
     friend class DoFHandler<dim>;
     friend class MGDoFHandler<dim>;
 };
index 275a1d74b4073d1b2167c7dd7bc2a430fab11ae4..3b3c39f8bbf40f74d83a466bd7cca8174a8be564 100644 (file)
@@ -12,6 +12,8 @@
 // forward declaration needed
 class Line;
 class Quad;
+class Hexahedron;
+
 template <int dim> class Point;
 
 
@@ -191,6 +193,14 @@ class TriaAccessor {
                                     /**
                                      *  Exception
                                      */
+    DeclException1 (ExcCantSetChildren,
+                   int,
+                   << "You can only set the child index if the cell has no "
+                   << "children, or clear it. The given "
+                   << "index was " << arg1 << " (-1 means: clear children)");
+                                    /**
+                                     * Exception
+                                     */
     DeclException0 (ExcUnusedCellAsNeighbor);
                                     /**
                                      *  Exception
@@ -240,29 +250,11 @@ class TriaAccessor {
                                      */
     Triangulation<dim> *tria;
 
-    friend class TriaRawIterator<1,LineAccessor<1> >;
-    friend class TriaRawIterator<1,CellAccessor<1> >;
-    friend class TriaRawIterator<2,LineAccessor<2> >;
-    friend class TriaRawIterator<2,QuadAccessor<2> >;
-    friend class TriaRawIterator<2,CellAccessor<2> >;
-
-    friend class TriaIterator<1,LineAccessor<1> >;
-    friend class TriaIterator<1,CellAccessor<1> >;
-    friend class TriaIterator<2,LineAccessor<2> >;
-    friend class TriaIterator<2,QuadAccessor<2> >;
-    friend class TriaIterator<2,CellAccessor<2> >;
-
-    friend class TriaActiveIterator<1,LineAccessor<1> >;
-    friend class TriaActiveIterator<1,CellAccessor<1> >;
-    friend class TriaActiveIterator<2,LineAccessor<2> >;
-    friend class TriaActiveIterator<2,QuadAccessor<2> >;
-    friend class TriaActiveIterator<2,CellAccessor<2> >;
-
-    friend class TriaRawIterator<1,DoFCellAccessor<1> >;
-    friend class TriaRawIterator<2,DoFCellAccessor<2> >;
+    template <int dim, typename Accessor> friend class TriaRawIterator<dim,Accessor>;
+    template <int dim, typename Accessor> friend class TriaIterator<dim,Accessor>;
+    template <int dim, typename Accessor> friend class TriaActiveIterator<dim,Accessor>;
+
     friend class TriaRawIterator<2,DoFLineAccessor<2,LineAccessor<2> > >;
-    friend class TriaIterator<1,DoFCellAccessor<1> >;
-    friend class TriaIterator<2,DoFCellAccessor<2> >;
     friend class TriaIterator<2,DoFLineAccessor<2,LineAccessor<2> > >;
 };
 
@@ -276,7 +268,7 @@ class TriaAccessor {
  *   Accessor to dereference the data of lines. This accessor is used to
  *   point to lines in #dim# space dimensions. There is a derived class
  *   for lines in one space dimension, in which case a line is also a cell
- *   and thus has much more functionality than in lower dimensions.
+ *   and thus has much more functionality than in other dimensions.
  *
  *   @author Wolfgang Bangerth, 1998
  */
@@ -541,12 +533,7 @@ class LineAccessor :  public TriaAccessor<dim> {
 
     
 
-  public:
-//  protected:
-                                    // would be better to make this private,
-                                    // but that would require making all
-                                    // TriaRawIterator<...>s friend.->wait for
-                                    // gcc 2.30687
+  protected:
     
                                     /**@name Advancement of iterators*/
                                     /*@{*/
@@ -574,6 +561,12 @@ class LineAccessor :  public TriaAccessor<dim> {
                                      */
     void operator -- ();
                                     /*@}*/
+
+                                    /**
+                                     * Declare some friends.
+                                     */
+    template <int dim> friend class TriaRawIterator<dim,LineAccessor<dim> >;
+    template <>        friend class TriaRawIterator<1,CellAccessor<1> >;
 };
 
 
@@ -583,7 +576,7 @@ class LineAccessor :  public TriaAccessor<dim> {
  *   point to quads in #dim# space dimensions (only #dim>=2# seems reasonable
  *   to me). There is a derived class
  *   for quads in two space dimension, in which case a quad is also a cell
- *   and thus has much more functionality than in lower dimensions.
+ *   and thus has much more functionality than in other dimensions.
  *
  *   @author Wolfgang Bangerth, 1998
  */
@@ -685,20 +678,20 @@ class QuadAccessor :  public TriaAccessor<dim> {
     void recursively_clear_user_flag () const;
 
                                     /**
-                                     * Set the user pointer of this line
+                                     * Set the user pointer of this quad
                                      * to #p#.
                                      */
     void set_user_pointer (void *p) const;
 
                                     /**
-                                     * Reset the user pointer of this line
+                                     * Reset the user pointer of this quad
                                      * to a #NULL# pointer.
                                      */
     void clear_user_pointer () const;
 
                                     /**
                                      * Access the value of the user pointer
-                                     * of this line. It is in the
+                                     * of this quad. It is in the
                                      * responsibility of the user to make
                                      * sure that the pointer points to
                                      * something useful. You should use the
@@ -748,18 +741,18 @@ class QuadAccessor :  public TriaAccessor<dim> {
 
                                     /**
                                      * Return the boundary indicator of this
-                                     * line. Since boundary data is only useful
+                                     * quad. Since boundary data is only useful
                                      * for structures with a dimension less
                                      * than the dimension of a cell, this
                                      * function issues an error if #dim<3#.
                                      *
                                      * If the return value is 255, then this
-                                     * line is in the interior of the domain.
+                                     * quad is in the interior of the domain.
                                      */
     unsigned char boundary_indicator () const;
 
                                     /**
-                                     * Set the boundary indicator of this line.
+                                     * Set the boundary indicator of this quad.
                                      * The same applies as for the
                                      * #boundary_indicator()# function.
                                      *
@@ -780,9 +773,9 @@ class QuadAccessor :  public TriaAccessor<dim> {
                                      * Return whether this line is at the
                                      * boundary. This is checked via the
                                      * the boundary indicator field, which
-                                     * is always 255 if the line is in the
+                                     * is always 255 if the quad is in the
                                      * interior of the domain. Obviously,
-                                     * this is only possible for #dim>2#;
+                                     * this function is only useful for #dim>2#;
                                      * however, for #dim==2#, a quad is
                                      * a cell and the #CellAccessor# class
                                      * offers another possibility to
@@ -832,9 +825,8 @@ class QuadAccessor :  public TriaAccessor<dim> {
     Point<dim> center () const;
 
                                     /**
-                                     * Return the barycenter of the aud,
-                                     * which is the midpoint. The same
-                                     * applies as for the #center# function
+                                     * Return the barycenter of the qaud. The
+                                     * same applies as for the #center# function
                                      * with regard to quads at the boundary.
                                      */
     Point<dim> barycenter () const;
@@ -888,13 +880,355 @@ class QuadAccessor :  public TriaAccessor<dim> {
                                      */
     void operator = (const QuadAccessor &);
 
+  protected:
+                                    /**@name Advancement of iterators*/
+                                    /*@{*/
+                                    /**
+                                     *  This operator advances the iterator to
+                                     *  the next element.
+                                     *
+                                     *  The next element is next on this
+                                     *  level if there are more. If the
+                                     *  present element is the last on
+                                     *  this level, the first on the
+                                     *  next level is accessed.
+                                     */
+    void operator ++ ();
+
+                                    /**
+                                     *  This operator moves the iterator to
+                                     *  the previous element.
+                                     *
+                                     *  The previous element is previous on
+                                     *  this level if #index>0#. If the
+                                     *  present element is the first on
+                                     *  this level, the last on the
+                                     *  previous level is accessed.
+                                     */
+    void operator -- ();
+                                    /*@}*/
+
+                                    /**
+                                     * Declare some friends.
+                                     */
+    template <int dim> friend class TriaRawIterator<dim,QuadAccessor<dim> >;
+    template <>        friend class TriaRawIterator<2,CellAccessor<2> >;
+};
+
+
+
+/**
+ *   Accessor to dereference the data of hexahedra. This accessor is used to
+ *   point to hexs in #dim# space dimensions (only #dim>=3# seems reasonable
+ *   to me). There is a derived class
+ *   for hexs in three space dimension, in which case a hex is also a cell
+ *   and thus has much more functionality than in other dimensions.
+ *
+ *   @author Wolfgang Bangerth, 1998
+ */
+template <int dim>
+class HexAccessor :  public TriaAccessor<dim> {
   public:
-//  protected:
-                                    // would be better to make this private,
-                                    // but that would require making all
-                                    // TriaRawIterator<...>s friend.->wait for
-                                    // gcc 2.30687
+                                    /**
+                                     *  Constructor.
+                                     */
+    HexAccessor (Triangulation<dim> *parent     = 0,
+                const int           level      = -1,
+                const int           index      = -1,
+                const void         *local_data = 0) :
+                   TriaAccessor<dim> (parent, level, index, local_data) {};
+
+                                    /**
+                                     *  Copy the data of the given hex.
+                                     */
+    void set (const Hexahedron &h) const;
+    
+                                    /**
+                                     *  Return index of vertex #i=0,...,7# of
+                                     *  a hex. The convention regarding the
+                                     *  numbering of vertices is laid down
+                                     *  in the documentation of the
+                                     *  #Triangulation# class.
+                                     */ 
+    int vertex_index (const unsigned int i) const;
+
+                                    /**
+                                     *  Return a reference (not an iterator!)
+                                     *  to the #i#th vertex.
+                                     */
+    Point<dim> & vertex (const unsigned int i) const;
+
+                                    /**
+                                     *  Return a pointer to the #i#th line
+                                     *  bounding this #Hex#.
+                                     */
+    TriaIterator<dim,LineAccessor<dim> > line (const unsigned int i) const;
+
+                                    /**
+                                     * Return the line index of the #i#th
+                                     * line. The level is naturally
+                                     * the same as that of the hex.
+                                     */
+    unsigned int line_index (const unsigned int i) const;
+    
+                                    /**
+                                     *  Return a pointer to the #i#th quad
+                                     *  bounding this #Hex#.
+                                     */
+    TriaIterator<dim,QuadAccessor<dim> > quad (const unsigned int i) const;
+
+                                    /**
+                                     * Return the quad index of the #i#th
+                                     * side (a quad). The level is naturally
+                                     * the same as that of the hex.
+                                     */
+    unsigned int quad_index (const unsigned int i) const;
+
+                                    /**
+                                     *  Test for the element being used
+                                     *  or not.
+                                     */
+    bool used () const;
+
+                                    /**
+                                     *  Set the #used# flag. You should know
+                                     *  quite exactly what you are doing of you
+                                     *  touch this function. It is exclusively
+                                     *  for internal use in the library.
+                                     */
+    void set_used_flag () const;
+
+                                    /**
+                                     *  Clear the #used# flag. You should know
+                                     *  quite exactly what you are doing of you
+                                     *  touch this function. It is exclusively
+                                     *  for internal use in the library.
+                                     */
+    void clear_used_flag () const;
+
+                                    /**
+                                     *  Return whether the user flag
+                                     *  is set or not.
+                                     */
+    bool user_flag_set () const;
+
+                                    /**
+                                     *  Flag the user flag for this cell.
+                                     */
+    void set_user_flag () const;
+
+                                    /**
+                                     *  Clear the user flag.
+                                     */
+    void clear_user_flag () const;
+
+                                    /**
+                                     *  set the user flag of this object
+                                     *  and of all its children and their
+                                     *  children, etc.
+                                     */
+    void recursively_set_user_flag () const;
+
+                                    /**
+                                     *  Clear the user flag of this object
+                                     *  and of all its children and their
+                                     *  children, etc.
+                                     */
+    void recursively_clear_user_flag () const;
+
+                                    /**
+                                     * Set the user pointer of this hex
+                                     * to #p#.
+                                     */
+    void set_user_pointer (void *p) const;
+
+                                    /**
+                                     * Reset the user pointer of this hex
+                                     * to a #NULL# pointer.
+                                     */
+    void clear_user_pointer () const;
+
+                                    /**
+                                     * Access the value of the user pointer
+                                     * of this hex. It is in the
+                                     * responsibility of the user to make
+                                     * sure that the pointer points to
+                                     * something useful. You should use the
+                                     * new style cast operator to maintain
+                                     * a minimum of typesafety, e.g.
+                                     * #A *a=static_cast<A*>(cell->user_pointer());#.
+                                     */
+    void * user_pointer () const;
+
+                                    /**
+                                     *  Return a pointer to the #i#th
+                                     *  child.
+                                     */
+    TriaIterator<dim,HexAccessor<dim> > child (const unsigned int i) const;
+
+                                    /**
+                                     *  Return the index of the #i#th child.
+                                     *  The level of the child is one higher
+                                     *  than that of the present cell.
+                                     *  If the child does not exist, -1
+                                     *  is returned.
+                                     */
+    int child_index (const unsigned int i) const;
+
+                                    /**
+                                     *  Set the child field. Since we
+                                     *  only store the index of the first
+                                     *  child (the others follow directly)
+                                     *  only one child index is to be
+                                     *  given. The level of the child is
+                                     *  one level up of the level of the
+                                     *  cell to which this iterator points.
+                                     */
+    void set_children (const int index) const;
+       
+                                    /**
+                                     *  Clear the child field, i.e. set
+                                     *  it to a value which indicates
+                                     *  that this cell has no children.
+                                     */
+    void clear_children () const;
+    
+                                    /**
+                                     *  Test whether the hex has children.
+                                     */
+    bool has_children () const;
+
+                                    /**
+                                     * Return the boundary indicator of this
+                                     * hex. Since boundary data is only useful
+                                     * for structures with a dimension less
+                                     * than the dimension of a cell, this
+                                     * function issues an error if #dim<4#.
+                                     *
+                                     * If the return value is 255, then this
+                                     * line is in the interior of the domain.
+                                     */
+    unsigned char boundary_indicator () const;
 
+                                    /**
+                                     * Set the boundary indicator of this hex.
+                                     * The same applies as for the
+                                     * #boundary_indicator()# function.
+                                     *
+                                     * You should be careful with this function
+                                     * and especially never try to set the
+                                     * boundary indicator to 255, unless
+                                     * you exactly know what you are doing,
+                                     * since this value is reserved for
+                                     * another purpose and algorithms may
+                                     * not work if boundary cells have have
+                                     * this boundary indicator or if interior
+                                     * cells have boundary indicators other
+                                     * than 255.
+                                     */
+    void set_boundary_indicator (unsigned char) const;
+
+                                    /**
+                                     * Return whether this hex is at the
+                                     * boundary. This is checked via
+                                     * the boundary indicator field, which
+                                     * is always 255 if the hex is in the
+                                     * interior of the domain. Obviously,
+                                     * the use of this function is only
+                                     * possible for #dim>3#;
+                                     * however, for #dim==3#, a hex is
+                                     * a cell and the #CellAccessor# class
+                                     * offers another possibility to
+                                     * determine whether a cell is at the
+                                     * boundary or not.
+                                     */
+    bool at_boundary () const;
+
+                                    /**
+                                     * Return the diameter of the hex.
+                                     *
+                                     * The diameter of a hex is computed to
+                                     * be the largest diagonal. You
+                                     * should absolutely be clear about the
+                                     * fact that this definitely is not the
+                                     * diameter of all hexahedra; however
+                                     * it may serve as an approximation and
+                                     * is exact in many cases, especially
+                                     * if the hexahedron is not too much
+                                     * distorted.
+                                     */
+    double diameter () const;
+
+                                    /**
+                                     * Return the center of the hex. The
+                                     * center of a hex is defined to be
+                                     * the average of the vertices,
+                                     * which is also the point where the
+                                     * trilinear mapping places the midpoint
+                                     * of the unit hex in real space.
+                                     * However, this may not be the point
+                                     * of the barycenter of the hex.
+                                     */
+    Point<dim> center () const;
+
+                                    /**
+                                     * Return the barycenter of the hex.
+                                     */
+    Point<dim> barycenter () const;
+
+                                    /**
+                                     * Return the volume of the hex. With
+                                     * volume, we mean the area included by
+                                     * the hexahedron if its faces are
+                                     * supposed to be derived by a trilinear
+                                     * mapping from the unit cell, only using
+                                     * the location of the vertices.
+                                     * Therefore, no information
+                                     * about the boundary is used; if
+                                     * you want other than trilinearly
+                                     * mapped unit hexahedra, ask the
+                                     * appropriate finite element class
+                                     * for the volume.
+                                     */
+    double measure () const;
+
+                                    /**
+                                     * Compute and return the number of
+                                     * children of this hex. Actually,
+                                     * this function only counts the number
+                                     * of active children, i.e. the number
+                                     * if hexs which are not further
+                                     * refined. Thus, if all of the eight
+                                     * children of a hex are further
+                                     * refined exactly once, the returned
+                                     * number will be 64, not 80.
+                                     *
+                                     * If the present cell is not refined,
+                                     * one is returned.
+                                     */
+    unsigned int number_of_children () const;
+
+  private:
+                                    /**
+                                     *  Copy operator. This is normally
+                                     *  used in a context like
+                                     *  #iterator a,b;  *a=*b;#. Since
+                                     *  the meaning is to copy the object
+                                     *  pointed to by #b# to the object
+                                     *  pointed to by #a# and since
+                                     *  accessors are not real but
+                                     *  virtual objects, this operation
+                                     *  is not useful for iterators on
+                                     *  triangulations. We declare this
+                                     *  function here private, thus it may
+                                     *  not be used from outside.
+                                     *  Furthermore it is not implemented
+                                     *  and will give a linker error if
+                                     *  used anyway.
+                                     */
+    void operator = (const HexAccessor &);
+
+  protected:
                                     /**@name Advancement of iterators*/
                                     /*@{*/
                                     /**
@@ -921,11 +1255,20 @@ class QuadAccessor :  public TriaAccessor<dim> {
                                      */
     void operator -- ();
                                     /*@}*/
+
+                                    /**
+                                     * Declare some friends.
+                                     */
+    template <int dim> friend class TriaRawIterator<dim,HexAccessor<dim> >;
+    template <>        friend class TriaRawIterator<3,CellAccessor<3> >;
 };
 
 
 
 
+
+
+
 /**
  * Intermediate, "typedef"-class, not for public use.
  */
@@ -945,6 +1288,7 @@ class TriaSubstructAccessor;
  * \begin{verbatim}
  *   TriaSubstructAccessor<1> := LineAccessor<1>;
  *   TriaSubstructAccessor<2> := QuadAccessor<2>;
+ *   TriaSubstructAccessor<3> := HexAccessor<3>;
  * \end{verbatim}
  * We do this rather complex (and needless, provided C++ the needed constructs!)
  * class hierarchy manipulation, since this way we can declare and implement
@@ -1007,6 +1351,34 @@ class TriaSubstructAccessor<2> : public QuadAccessor<2> {
 
 
 
+/**
+ * Intermediate, "typedef"-class, not for public use.
+ *
+ * @see TriaSubstructAccessor<1>
+ */
+template <>
+class TriaSubstructAccessor<3> : public HexAccessor<3> {
+  public:
+                                    /**
+                                     * Constructor
+                                     */
+    TriaSubstructAccessor (Triangulation<3> *tria,
+                          const int         level,
+                          const int         index,
+                          const void       *local_data) :
+                   HexAccessor<3> (tria,level,index,local_data) {};
+
+                                    // do this here, since this way the
+                                    // CellAccessor has the possibility to know
+                                    // what a substruct_iterator is. Otherwise
+                                    // it would have to ask the DoFHandler<dim>
+                                    // which would need another big include
+                                    // file and maybe cyclic interdependence
+    typedef TriaIterator<3,QuadAccessor<3> > substruct_iterator;
+};
+
+
+
 
 
 
index 65dea7aae8c5cef0aaefba426e29da9f2d7a4226..0dc0afe7ae459ae48ecec5ccadd912ff051bfc80 100644 (file)
@@ -216,7 +216,7 @@ template <int dim> class Triangulation;
  *   @author Wolfgang Bangerth, 1998
  */
 template <int dim, typename Accessor>
-class TriaRawIterator : public bidirectional_iterator<Accessor,int>{
+class TriaRawIterator : public bidirectional_iterator<Accessor,int> {
   public:
                                     /**
                                      * Declare the type of the Accessor for
index 619ed67bb33ef21875e0e7652f905a053d38f323..3ce7b84c0c8507ae3385f86dced20efe93c35a61 100644 (file)
@@ -8,6 +8,10 @@
 
 #include <base/exceptions.h>
 
+
+template <int dim> class Triangulation;
+
+
 /**
  *   #Quad#s denote the fundamental entities of triangulations in two dimensions
  *   and the boundaries of hexaeders in three dimensions. They are
index 37a6cfb5ee635fd6c7344dc364084169380e560f..0ee7b25e6bed867eff4452e1916f1114da4410d6 100644 (file)
@@ -333,6 +333,115 @@ class MGDoFQuadAccessor :  public MGDoFAccessor<dim>, public DoFQuadAccessor<dim
 
 
 
+/**
+ * Grant access to the multilevel degrees of freedom located on hexhedra.
+ *
+ * @see DoFLineAccessor
+ */
+template <int dim, typename BaseClass>
+class MGDoFHexAccessor :  public MGDoFAccessor<dim>, public DoFHexAccessor<dim, BaseClass> {
+  public:
+                                    /**
+                                     * Declare the data type that this accessor
+                                     * class expects to get passed from the
+                                     * iterator classes.
+                                     */
+    typedef MGDoFHandler<dim> AccessorData;
+
+                                    /**
+                                     * Default constructor, unused thus
+                                     * not implemented.
+                                     */
+    MGDoFHexAccessor ();
+
+                                    /**
+                                     * Constructor. The #local_data#
+                                     * argument is assumed to be a pointer
+                                     * to a #DoFHandler<dim># object.
+                                     */
+    MGDoFHexAccessor (Triangulation<dim> *tria,
+                     const int           level,
+                     const int           index,
+                     const AccessorData *local_data);
+    
+                                    /**
+                                     * Return the index of the #i#th degree
+                                     * of freedom of this hex on the level
+                                     * this quad lives on.
+                                     */
+    int mg_dof_index (const unsigned int i) const;
+
+                                    /**
+                                     * Set the index of the #i#th degree
+                                     * of freedom of this hex on the
+                                     * level this hex lives on to #index#.
+                                     */
+    void set_mg_dof_index (const unsigned int i, const int index) const;
+
+                                    /**
+                                     * Return the index of the #i#th degree
+                                     * on the #vertex#th vertex for the level
+                                     * this hex lives on.
+                                     */
+    int mg_vertex_dof_index (const unsigned int vertex,
+                            const unsigned int i) const;
+
+                                    /**
+                                     * Set the index of the #i#th degree
+                                     * on the #vertex#th vertex for the
+                                     * level this hex lives on to #index#.
+                                     */
+    void set_mg_vertex_dof_index (const unsigned int vertex,
+                                 const unsigned int i,
+                                 const int          index) const;
+
+                                    /**
+                                     * Return the indices of the dofs of this
+                                     * hex in the standard ordering: dofs
+                                     * on vertex 0, dofs on vertex 1, etc,
+                                     * dofs on line 0, dofs on line 1, etc,
+                                     * dofs on quad 0, etc.
+                                     *
+                                     * It is assumed that the vector already
+                                     * has the right size beforehand. The
+                                     * indices refer to the local numbering
+                                     * for the level this hex lives on.
+                                     */
+    void get_mg_dof_indices (vector<int> &dof_indices) const;
+
+                                    /**
+                                     * Return a pointer to the #i#th line
+                                     * bounding this #Hex#.
+                                     */
+    TriaIterator<dim,MGDoFLineAccessor<dim,LineAccessor<dim> > >
+    line (const unsigned int i) const;
+
+                                    /**
+                                     * Return a pointer to the #i#th quad
+                                     * bounding this #Hex#.
+                                     */
+    TriaIterator<dim,MGDoFLineAccessor<dim,QuadAccessor<dim> > >
+    quad (const unsigned int i) const;
+
+                                    /**
+                                     * Return the #i#th child as a DoF quad
+                                     * iterator. This function is needed since
+                                     * the child function of the base
+                                     * class returns a hex accessor without
+                                     * access to the DoF data.
+                                     */
+    TriaIterator<dim,MGDoFHexAccessor<dim,BaseClass> > child (const unsigned int) const;
+    
+                                    /**
+                                     * Implement the copy operator needed
+                                     * for the iterator classes.
+                                     */
+    void copy_from (const MGDoFHexAccessor<dim,BaseClass> &a);
+};
+
+
+
+
 
 /**
  * Intermediate, "typedef"-class, not for public use.
@@ -445,6 +554,40 @@ class MGDoFSubstructAccessor<2> : public MGDoFQuadAccessor<2,CellAccessor<2> > {
 
 
 
+/**
+ * Intermediate, "typedef"-class, not for public use.
+ *
+ * @see MGDoFSubstructAccessor<1>
+ */
+template <>
+class MGDoFSubstructAccessor<3> : public MGDoFHexAccessor<3,CellAccessor<3> > {
+  public:
+                                    /**
+                                     * Declare the data type that this accessor
+                                     * class expects to get passed from the
+                                     * iterator classes.
+                                     */
+    typedef MGDoFHexAccessor<3,CellAccessor<3> >::AccessorData AccessorData;
+    
+                                    /**
+                                     * Constructor
+                                     */
+    MGDoFSubstructAccessor (Triangulation<3> *tria,
+                           const int         level,
+                           const int         index,
+                           const AccessorData *local_data) :
+                   MGDoFHexAccessor<3,CellAccessor<3> > (tria,level,index,local_data) {};
+                                    // do this here, since this way the
+                                    // CellAccessor has the possibility to know
+                                    // what a face_iterator is. Otherwise
+                                    // it would have to ask the DoFHandler<dim>
+                                    // which would need another big include
+                                    // file and maybe cyclic interdependence
+    typedef TriaIterator<3,MGDoFQuadAccessor<3,QuadAccessor<3> > > face_iterator;
+};
+
+
+
 
 
 
index f5d5b1e958f7e701d5e131090a9b7fdbfe84a695..6f80e19be70741f35348e9d4d267e9266c8dc0d9 100644 (file)
@@ -47,6 +47,10 @@ class MGDoFDimensionInfo<1> {
     typedef void * quad_iterator;
     typedef void * active_quad_iterator;
 
+    typedef void * raw_hex_iterator;
+    typedef void * hex_iterator;
+    typedef void * active_hex_iterator;
+
     typedef raw_line_iterator    raw_cell_iterator;
     typedef line_iterator        cell_iterator;
     typedef active_line_iterator active_cell_iterator;
@@ -76,6 +80,10 @@ class MGDoFDimensionInfo<2> {
     typedef TriaIterator<2,MGDoFCellAccessor<2> >                  quad_iterator;
     typedef TriaActiveIterator<2,MGDoFCellAccessor<2> >            active_quad_iterator;
 
+    typedef void * raw_hex_iterator;
+    typedef void * hex_iterator;
+    typedef void * active_hex_iterator;
+
     typedef raw_quad_iterator    raw_cell_iterator;
     typedef quad_iterator        cell_iterator;
     typedef active_quad_iterator active_cell_iterator;
@@ -88,6 +96,37 @@ class MGDoFDimensionInfo<2> {
 
 
 
+/**
+ * Define some types for the DoF handling in two dimensions.
+ *
+ * The types have the same meaning as those declared in \Ref{TriaDimensionInfo<2>}.
+ */
+class MGDoFDimensionInfo<3> {
+  public:
+    typedef TriaRawIterator<3,MGDoFLineAccessor<3,LineAccessor<3> > >    raw_line_iterator;
+    typedef TriaIterator<3,MGDoFLineAccessor<3,LineAccessor<3> > >       line_iterator;
+    typedef TriaActiveIterator<3,MGDoFLineAccessor<3,LineAccessor<3> > > active_line_iterator;
+
+    typedef TriaRawIterator<3,MGDoFQuadAccessor<3,QuadAccessor<3> > >    raw_quad_iterator;
+    typedef TriaIterator<3,MGDoFQuadAccessor<3,QuadAccessor<3> > >       quad_iterator;
+    typedef TriaActiveIterator<3,MGDoFQuadAccessor<3,QuadAccessor<3> > > active_quad_iterator;
+
+    typedef TriaRawIterator<3,MGDoFCellAccessor<3> >               raw_hex_iterator;
+    typedef TriaIterator<3,MGDoFCellAccessor<3> >                  hex_iterator;
+    typedef TriaActiveIterator<3,MGDoFCellAccessor<3> >            active_hex_iterator;
+
+    typedef raw_hex_iterator    raw_cell_iterator;
+    typedef hex_iterator        cell_iterator;
+    typedef active_hex_iterator active_cell_iterator;
+
+    typedef raw_quad_iterator    raw_face_iterator;
+    typedef quad_iterator        face_iterator;
+    typedef active_quad_iterator active_face_iterator;    
+};
+
+
+
+
 
 template <int dim>
 class MGDoFHandler : public DoFHandler<dim> {
index 6f091bcf945f7cc4b18cb07c3c53d4a483cfb0bb..b4460f78ab61e2db4c22dd44b64cdeb7824ccbd9 100644 (file)
@@ -31,6 +31,24 @@ go-files-2d = $(addprefix ../lib/2d/go/, $(tmp1:.cc=_2d.go))
 o-files-3d  = $(addprefix ../lib/3d/o/,  $(tmp1:.cc=_3d.o) )
 go-files-3d = $(addprefix ../lib/3d/go/, $(tmp1:.cc=_3d.go))
 
+
+
+
+
+default: 2d
+all: 1d 2d 3d
+
+1d: ../lib/libdeal_II_1d.g.a ../lib/libdeal_II_1d.a
+
+2d: ../lib/libdeal_II_2d.g.a ../lib/libdeal_II_2d.a
+
+3d: ../lib/libdeal_II_3d.g.a ../lib/libdeal_II_3d.a
+
+
+
+# rules how to generate object files from source files. note that
+# there are some files which needs exceptional rules; these are
+# listed immediately below
 ../lib/1d/go/%.go :
        @echo ==============1d======debug============= $<
        @$(CXX) $(CXXFLAGS.g) -Ddeal_II_dimension=1 -c $< -o $@
@@ -52,19 +70,13 @@ go-files-3d = $(addprefix ../lib/3d/go/, $(tmp1:.cc=_3d.go))
        @echo ==============3d======optimized========= $<
        @$(CXX) $(CXXFLAGS) -Ddeal_II_dimension=3 -c $< -o $@
 
+# special rules for exceptional files
+../lib/3d/o/fe_linear_mapping.jacobians_3d.o:
+       @echo "==============3d======opt==(special)====" $<
+       @$(CXX) $(filter-out -O2 -Wuninitialized,$(CXXFLAGS)) -Ddeal_II_dimension=3 -c $< -o $@
 
 
 
-default: 2d
-all: 1d 2d 3d
-
-1d: ../lib/libdeal_II_1d.g.a ../lib/libdeal_II_1d.a
-
-2d: ../lib/libdeal_II_2d.g.a ../lib/libdeal_II_2d.a
-
-3d: ../lib/libdeal_II_3d.g.a ../lib/libdeal_II_3d.a
-
-
 
 ../lib/libdeal_II_1d.g.a: $(go-files-1d)
        @echo ======================================== Updating library:   $@
index c55ffbac34a259892f1a83c497401a5ff5a52cac..8de719c16ae27dc4a95eebb01789bd00da56afc1 100644 (file)
@@ -390,6 +390,226 @@ void DoFQuadAccessor<dim,BaseClass>::copy_from (const DoFQuadAccessor<dim,BaseCl
 
 
 
+/*------------------------- Functions: DoFHexAccessor -----------------------*/
+
+
+template <int dim, typename BaseClass>
+inline
+int DoFHexAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+                                  // make sure a FE has been selected
+                                  // and enough room was reserved
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (i<dof_handler->selected_fe->dofs_per_hex,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_hex));
+
+  return dof_handler->levels[present_level]
+    ->hex_dofs[present_index*dof_handler->selected_fe->dofs_per_hex+i];
+};
+
+
+
+template <int dim, typename BaseClass>
+void DoFHexAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
+                                                   const int index) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+                                  // make sure a FE has been selected
+                                  // and enough room was reserved
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (i<dof_handler->selected_fe->dofs_per_hex,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_hex));
+
+  dof_handler->levels[present_level]
+    ->hex_dofs[present_index*dof_handler->selected_fe->dofs_per_hex+i] = index;
+};
+
+
+
+template <int dim, typename BaseClass>
+inline
+int DoFHexAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
+                                                     const unsigned int i) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (vertex<8, ExcInvalidIndex (i,0,8));
+  Assert (i<dof_handler->selected_fe->dofs_per_vertex,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_vertex));
+
+  const unsigned int dof_number = (vertex_index(vertex) *
+                                  dof_handler->selected_fe->dofs_per_vertex +
+                                  i);
+  return dof_handler->vertex_dofs[dof_number];
+};
+
+
+  
+template <int dim, typename BaseClass>
+void DoFHexAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int vertex,
+                                                          const unsigned int i,
+                                                          const int index) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (vertex<8, ExcInvalidIndex (i,0,8));
+  Assert (i<dof_handler->selected_fe->dofs_per_vertex,
+         ExcInvalidIndex (i, 0, dof_handler->selected_fe->dofs_per_vertex));
+
+  const unsigned int dof_number = (vertex_index(vertex) *
+                                  dof_handler->selected_fe->dofs_per_vertex +
+                                  i);
+  dof_handler->vertex_dofs[dof_number] = index;
+};
+
+
+
+template <int dim, typename BaseClass>
+void
+DoFHexAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_indices.size() == (8*dof_handler->get_fe().dofs_per_vertex +
+                                12*dof_handler->get_fe().dofs_per_line +
+                                6*dof_handler->get_fe().dofs_per_quad +
+                                dof_handler->get_fe().dofs_per_hex),
+         ExcVectorDoesNotMatch());
+
+  const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
+                    dofs_per_line   = dof_handler->get_fe().dofs_per_line,
+                    dofs_per_quad   = dof_handler->get_fe().dofs_per_quad,
+                    dofs_per_hex    = dof_handler->get_fe().dofs_per_hex;
+  vector<int>::iterator next = dof_indices.begin();
+  for (unsigned int vertex=0; vertex<8; ++vertex)
+    for (unsigned int d=0; d<dofs_per_vertex; ++d)
+      *next++ = vertex_dof_index(vertex,d);
+  for (unsigned int line=0; line<12; ++line)
+    for (unsigned int d=0; d<dofs_per_line; ++d)
+      *next++ = this->line(line)->dof_index(d);
+  for (unsigned int quad=0; quad<6; ++quad)
+    for (unsigned int d=0; d<dofs_per_quad; ++d)
+      *next++ = this->quad(quad)->dof_index(d);
+  for (unsigned int d=0; d<dofs_per_hex; ++d)
+    *next++ = dof_index(d);
+};
+
+
+
+template <int dim, typename BaseClass>
+TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
+DoFHexAccessor<dim,BaseClass>::line (const unsigned int i) const {
+  TriaIterator<dim,LineAccessor<dim> > l = BaseClass::line(i);
+  return TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
+    (
+      tria,
+      present_level,
+      l->index(),
+      dof_handler
+    );
+};
+
+
+
+template <int dim, typename BaseClass>
+TriaIterator<dim,DoFQuadAccessor<dim,QuadAccessor<dim> > >
+DoFHexAccessor<dim,BaseClass>::quad (const unsigned int i) const {
+  Assert (i<6, ExcInvalidIndex (i, 0, 6));
+
+  return TriaIterator<dim,DoFQuadAccessor<dim,QuadAccessor<dim> > >
+    (
+      tria,
+      present_level,
+      quad_index (i),
+      dof_handler
+    );
+};
+
+
+
+template <int dim, typename BaseClass>
+TriaIterator<dim,DoFHexAccessor<dim,BaseClass> >
+DoFHexAccessor<dim,BaseClass>::child (const unsigned int i) const {
+  TriaIterator<dim,DoFHexAccessor<dim,BaseClass> > q (tria,
+                                                     present_level+1,
+                                                     child_index (i),
+                                                     dof_handler);
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+template <int dim, typename BaseClass>
+void DoFHexAccessor<dim,BaseClass>::
+distribute_local_to_global (const dVector &local_source,
+                           dVector       &global_destination) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (local_source.size() == (8*dof_handler->get_fe().dofs_per_vertex +
+                                 12*dof_handler->get_fe().dofs_per_line +
+                                 6*dof_handler->get_fe().dofs_per_quad +
+                                 dof_handler->get_fe().dofs_per_hex),
+         ExcVectorDoesNotMatch());
+  Assert (dof_handler->n_dofs() == global_destination.size(),
+         ExcVectorDoesNotMatch());
+
+  const unsigned int n_dofs = local_source.size();
+
+                                  // get indices of dofs
+  vector<int> dofs (n_dofs);
+  get_dof_indices (dofs);
+  
+                                  // distribute cell vector
+  for (unsigned int j=0; j<n_dofs; ++j)
+    global_destination(dofs[j]) += local_source(j);
+};
+
+
+
+template <int dim, typename BaseClass>
+void DoFHexAccessor<dim,BaseClass>::
+distribute_local_to_global (const dFMatrix &local_source,
+                           dSMatrix       &global_destination) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (local_source.m() == (8*dof_handler->get_fe().dofs_per_vertex +
+                              12*dof_handler->get_fe().dofs_per_line +
+                              6*dof_handler->get_fe().dofs_per_quad +
+                              dof_handler->get_fe().dofs_per_hex),
+         ExcMatrixDoesNotMatch());
+  Assert (local_source.m() == local_source.n(),
+         ExcMatrixDoesNotMatch());
+  Assert (dof_handler->n_dofs() == global_destination.m(),
+         ExcMatrixDoesNotMatch());
+  Assert (global_destination.m() == global_destination.n(),
+         ExcMatrixDoesNotMatch());
+  
+  const unsigned int n_dofs = local_source.m();
+
+                                  // get indices of dofs
+  vector<int> dofs (n_dofs);
+  get_dof_indices (dofs);
+  
+                                  // distribute cell matrix
+  for (unsigned int i=0; i<n_dofs; ++i)
+    for (unsigned int j=0; j<n_dofs; ++j)
+      global_destination.add(dofs[i], dofs[j], local_source(i,j));
+};
+
+
+
+template <int dim, typename BaseClass>
+void DoFHexAccessor<dim,BaseClass>::copy_from (const DoFHexAccessor<dim,BaseClass> &a) {
+  BaseClass::copy_from (a);
+  set_dof_handler (a.dof_handler);
+};
+
+
+
+
+
+
 
 /*------------------------- Functions: DoFCellAccessor -----------------------*/
 
@@ -560,6 +780,84 @@ DoFCellAccessor<2>::set_dof_values (const dVector &local_values,
 
 
 
+#if deal_II_dimension == 3
+
+template <>
+DoFSubstructAccessor<3>::face_iterator
+DoFCellAccessor<3>::face (const unsigned int i) const {
+  return quad(i);
+};
+
+
+
+template <>
+void
+DoFCellAccessor<3>::get_dof_values (const dVector &values,
+                                   dVector       &local_values) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (&dof_handler->get_fe() != 0, ExcInvalidObject());
+  Assert (local_values.size() == dof_handler->get_fe().total_dofs,
+         ExcVectorDoesNotMatch());
+  Assert (values.size() == dof_handler->n_dofs(),
+         ExcVectorDoesNotMatch());
+  Assert (active(), ExcNotActive());
+  
+  const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
+                    dofs_per_line   = dof_handler->get_fe().dofs_per_line,
+                    dofs_per_quad   = dof_handler->get_fe().dofs_per_quad,
+                    dofs_per_hex    = dof_handler->get_fe().dofs_per_hex;
+  vector<double>::iterator next_local_value=local_values.begin();
+  for (unsigned int vertex=0; vertex<8; ++vertex)
+    for (unsigned int d=0; d<dofs_per_vertex; ++d)
+      *next_local_value++ = values(vertex_dof_index(vertex,d));
+  for (unsigned int line=0; line<12; ++line)
+    for (unsigned int d=0; d<dofs_per_line; ++d)
+      *next_local_value++ = values(this->line(line)->dof_index(d));
+  for (unsigned int quad=0; quad<6; ++quad)
+    for (unsigned int d=0; d<dofs_per_quad; ++d)
+      *next_local_value++ = values(this->quad(quad)->dof_index(d));
+  for (unsigned int d=0; d<dofs_per_hex; ++d)
+    *next_local_value++ = values(dof_index(d));
+};
+
+
+
+template <>
+void
+DoFCellAccessor<3>::set_dof_values (const dVector &local_values,
+                                   dVector       &values) const {
+  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (&dof_handler->get_fe() != 0, ExcInvalidObject());
+  Assert (local_values.size() == dof_handler->get_fe().total_dofs,
+         ExcVectorDoesNotMatch());
+  Assert (values.size() == dof_handler->n_dofs(),
+         ExcVectorDoesNotMatch());
+  Assert (active(), ExcNotActive());
+  
+  const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
+                    dofs_per_line   = dof_handler->get_fe().dofs_per_line,
+                    dofs_per_quad   = dof_handler->get_fe().dofs_per_quad,
+                    dofs_per_hex    = dof_handler->get_fe().dofs_per_hex;
+  vector<double>::const_iterator next_local_value=local_values.begin();
+  for (unsigned int vertex=0; vertex<8; ++vertex)
+    for (unsigned int d=0; d<dofs_per_vertex; ++d)
+      values(vertex_dof_index(vertex,d)) = *next_local_value++;
+  for (unsigned int line=0; line<12; ++line)
+    for (unsigned int d=0; d<dofs_per_line; ++d)
+      values(this->line(line)->dof_index(d)) = *next_local_value++;
+  for (unsigned int quad=0; quad<6; ++quad)
+    for (unsigned int d=0; d<dofs_per_quad; ++d)
+      values(this->quad(quad)->dof_index(d)) = *next_local_value++;
+  for (unsigned int d=0; d<dofs_per_hex; ++d)
+    values(dof_index(d)) = *next_local_value++;
+};
+
+
+
+#endif
+
+
+
 
 template <int dim>
 void
@@ -679,3 +977,24 @@ template class TriaActiveIterator<2,DoFCellAccessor<2> >;
 #endif
 
 
+
+#if deal_II_dimension == 3
+template class DoFLineAccessor<3,LineAccessor<3> >;
+template class DoFQuadAccessor<3,QuadAccessor<3> >;
+template class DoFHexAccessor<3,HexAccessor<3> >;
+template class DoFHexAccessor<3,CellAccessor<3> >;
+template class DoFCellAccessor<3>;
+
+template class TriaRawIterator<3,DoFLineAccessor<3,LineAccessor<3> > >;
+template class TriaRawIterator<3,DoFQuadAccessor<3,QuadAccessor<3> > >;
+template class TriaRawIterator<3,DoFHexAccessor<3,HexAccessor<3> > >;
+template class TriaRawIterator<3,DoFCellAccessor<3> >;
+template class TriaIterator<3,DoFLineAccessor<3,LineAccessor<3> > >;
+template class TriaIterator<3,DoFQuadAccessor<3,QuadAccessor<3> > >;
+template class TriaIterator<3,DoFCellAccessor<3> >;
+template class TriaActiveIterator<3,DoFLineAccessor<3,LineAccessor<3> > >;
+template class TriaActiveIterator<3,DoFQuadAccessor<3,QuadAccessor<3> > >;
+template class TriaActiveIterator<3,DoFCellAccessor<3> >;
+#endif
+
+
index 1a7ec28737dd52c20bc09ae81d257c926f746a53..396b7ad1cfe18071438fc7689268c9e4ff1a8bf8 100644 (file)
@@ -236,55 +236,61 @@ void ConstraintMatrix::condense (dSMatrixStruct &sparsity) const {
 
   int n_rows = sparsity.n_rows();
   for (int row=0; row<n_rows; ++row)
-    if (distribute[row] == -1)
-                                      // regular line. loop over cols
-      for (unsigned int j=sparsity.get_rowstart_indices()[row];
-          j<sparsity.get_rowstart_indices()[row+1]; ++j)
-                                        // end of row reached?
-       if (sparsity.get_column_numbers()[j] == -1)
-         break;
-       else
-         {
-           if (distribute[sparsity.get_column_numbers()[j]] != -1)
-                                              // distribute entry at regular
-                                              // row #row# and irregular column
-                                              // sparsity.colnums[j]
-             for (unsigned int q=0;
-                  q!=lines[distribute[sparsity.get_column_numbers()[j]]].entries.size();
-                  ++q) 
-               sparsity.add (row,
-                             lines[distribute[sparsity.get_column_numbers()[j]]].
-                             entries[q].first);
-         }
-    else
-                                      // row must be distributed
-      for (unsigned int j=sparsity.get_rowstart_indices()[row];
-          j<sparsity.get_rowstart_indices()[row+1]; ++j)
-                                        // end of row reached?
-       if (sparsity.get_column_numbers()[j] == -1)
-         break;
-       else
+    {
+      if (distribute[row] == -1)
+                                        // regular line. loop over cols
+       for (unsigned int j=sparsity.get_rowstart_indices()[row];
+            j<sparsity.get_rowstart_indices()[row+1]; ++j)
          {
-           if (distribute[sparsity.get_column_numbers()[j]] == -1)
-                                              // distribute entry at irregular
-                                              // row #row# and regular column
-                                              // sparsity.colnums[j]
-             for (unsigned int q=0;
-                  q!=lines[distribute[row]].entries.size(); ++q) 
-               sparsity.add (lines[distribute[row]].entries[q].first,
-                             sparsity.get_column_numbers()[j]);
+           const int column = sparsity.get_column_numbers()[j];
+           
+                                            // end of row reached?
+           if (column == -1)
+             break;
            else
-                                              // distribute entry at irregular
-                                              // row #row# and irregular column
-                                              // sparsity.get_column_numbers()[j]
-             for (unsigned int p=0; p!=lines[distribute[row]].entries.size(); ++p)
+             if (distribute[column] != -1)
+               {
+                                                  // distribute entry at regular
+                                                  // row #row# and irregular column
+                                                  // sparsity.colnums[j]
+                 for (unsigned int q=0;
+                      q!=lines[distribute[column]].entries.size();
+                      ++q) 
+                   sparsity.add (row,
+                                 lines[distribute[column]].entries[q].first);
+               };
+         }
+      else
+                                        // row must be distributed
+       for (unsigned int j=sparsity.get_rowstart_indices()[row];
+            j<sparsity.get_rowstart_indices()[row+1]; ++j)
+                                          // end of row reached?
+         if (sparsity.get_column_numbers()[j] == -1)
+           break;
+         else
+           {
+             if (distribute[sparsity.get_column_numbers()[j]] == -1)
+                                                // distribute entry at irregular
+                                                // row #row# and regular column
+                                                // sparsity.colnums[j]
                for (unsigned int q=0;
-                    q!=lines[distribute[sparsity.get_column_numbers()[j]]]
-                                   .entries.size(); ++q)
-                 sparsity.add (lines[distribute[row]].entries[p].first,
-                               lines[distribute[sparsity.get_column_numbers()[j]]]
-                               .entries[q].first);
-         };
+                    q!=lines[distribute[row]].entries.size(); ++q) 
+                 sparsity.add (lines[distribute[row]].entries[q].first,
+                               sparsity.get_column_numbers()[j]);
+             else
+                                                // distribute entry at irregular
+                                                // row #row# and irregular column
+                                                // sparsity.get_column_numbers()[j]
+               for (unsigned int p=0; p!=lines[distribute[row]].entries.size(); ++p)
+                 for (unsigned int q=0;
+                      q!=lines[distribute[sparsity.get_column_numbers()[j]]]
+                                     .entries.size(); ++q)
+                   sparsity.add (lines[distribute[row]].entries[p].first,
+                                 lines[distribute[sparsity.get_column_numbers()[j]]]
+                                 .entries[q].first);
+           };
+    };
+  
   sparsity.compress();
 };
 
@@ -437,83 +443,95 @@ void ConstraintMatrix::condense (dSMatrix &uncondensed) const {
     distribute[lines[c].line] = static_cast<signed int>(c);
 
   int n_rows = sparsity.n_rows();
-  for (int row=0; row<n_rows; ++row) 
+  for (int row=0; row<n_rows; ++row)
     {
-      
-    if (distribute[row] == -1)
-                                      // regular line. loop over cols
-      for (unsigned int j=sparsity.get_rowstart_indices()[row];
-          j<sparsity.get_rowstart_indices()[row+1]; ++j)
-                                        // end of row reached?
-       if (sparsity.get_column_numbers()[j] == -1)
-         break;
-       else
-         {
-           if (distribute[sparsity.get_column_numbers()[j]] != -1)
-                                              // distribute entry at regular
-                                              // row #row# and irregular column
-                                              // sparsity.get_column_numbers()[j]; set old
-                                              // entry to zero
-             {
-               for (unsigned int q=0;
-                    q!=lines[distribute[sparsity.get_column_numbers()[j]]]
-                                   .entries.size(); ++q) 
-                 uncondensed.add (row,
-                                  lines[distribute[sparsity.get_column_numbers()[j]]]
-                                  .entries[q].first,
-                                  uncondensed.global_entry(j) *
-                                  lines[distribute[sparsity.get_column_numbers()[j]]]
-                                  .entries[q].second);
-               uncondensed.global_entry(j) = 0.;
-             };
-         }
-    else
-                                      // row must be distributed
-      for (unsigned int j=sparsity.get_rowstart_indices()[row];
-          j<sparsity.get_rowstart_indices()[row+1]; ++j)
-                                        // end of row reached?
-       if (sparsity.get_column_numbers()[j] == -1)
-         break;
-       else
-         {
-           if (distribute[sparsity.get_column_numbers()[j]] == -1)
-                                              // distribute entry at irregular
-                                              // row #row# and regular column
-                                              // sparsity.get_column_numbers()[j]. set old
-                                              // entry to zero
-             {
-               for (unsigned int q=0;
-                    q!=lines[distribute[row]].entries.size(); ++q) 
-                 uncondensed.add (lines[distribute[row]].entries[q].first,
-                                  sparsity.get_column_numbers()[j],
-                                  uncondensed.global_entry(j) *
-                                  lines[distribute[row]].entries[q].second);
-               
-               uncondensed.global_entry(j) = 0.;
-             }
-           else
-                                              // distribute entry at irregular
-                                              // row #row# and irregular column
-                                              // sparsity.get_column_numbers()[j]
-                                              // set old entry to one if on main
-                                              // diagonal, zero otherwise
-             {
-               for (unsigned int p=0; p!=lines[distribute[row]].entries.size(); ++p)
+      if (distribute[row] == -1)
+                                        // regular line. loop over cols
+       for (unsigned int j=sparsity.get_rowstart_indices()[row];
+            j<sparsity.get_rowstart_indices()[row+1]; ++j)
+                                          // end of row reached?
+         if (sparsity.get_column_numbers()[j] == -1)
+           {
+                                              // this should not happen, since
+                                              // we only operate on compressed
+                                              // matrices!
+             Assert (false, ExcMatrixNotClosed());
+             break;
+           }
+         else
+           {
+             if (distribute[sparsity.get_column_numbers()[j]] != -1)
+                                                // distribute entry at regular
+                                                // row #row# and irregular column
+                                                // sparsity.get_column_numbers()[j]; set old
+                                                // entry to zero
+               {
                  for (unsigned int q=0;
                       q!=lines[distribute[sparsity.get_column_numbers()[j]]]
                                      .entries.size(); ++q)
-                   uncondensed.add (lines[distribute[row]].entries[p].first,
+                   uncondensed.add (row,
                                     lines[distribute[sparsity.get_column_numbers()[j]]]
                                     .entries[q].first,
                                     uncondensed.global_entry(j) *
-                                    lines[distribute[row]].entries[p].second *
                                     lines[distribute[sparsity.get_column_numbers()[j]]]
                                     .entries[q].second);
                
-               uncondensed.global_entry(j) = (row == sparsity.get_column_numbers()[j] ?
-                                     1. : 0. );
-             };
-         };
+                 uncondensed.global_entry(j) = 0.;
+               };
+           }
+      else
+                                        // row must be distributed
+       for (unsigned int j=sparsity.get_rowstart_indices()[row];
+            j<sparsity.get_rowstart_indices()[row+1]; ++j)
+                                          // end of row reached?
+         if (sparsity.get_column_numbers()[j] == -1)
+           {
+                                              // this should not happen, since
+                                              // we only operate on compressed
+                                              // matrices!
+             Assert (false, ExcMatrixNotClosed());
+             break;
+           }
+         else
+           {
+             if (distribute[sparsity.get_column_numbers()[j]] == -1)
+                                                // distribute entry at irregular
+                                                // row #row# and regular column
+                                                // sparsity.get_column_numbers()[j]. set old
+                                                // entry to zero
+               {
+                 for (unsigned int q=0;
+                      q!=lines[distribute[row]].entries.size(); ++q) 
+                   uncondensed.add (lines[distribute[row]].entries[q].first,
+                                    sparsity.get_column_numbers()[j],
+                                    uncondensed.global_entry(j) *
+                                    lines[distribute[row]].entries[q].second);
+               
+                 uncondensed.global_entry(j) = 0.;
+               }
+             else
+                                                // distribute entry at irregular
+                                                // row #row# and irregular column
+                                                // sparsity.get_column_numbers()[j]
+                                                // set old entry to one if on main
+                                                // diagonal, zero otherwise
+               {
+                 for (unsigned int p=0; p!=lines[distribute[row]].entries.size(); ++p)
+                   for (unsigned int q=0;
+                        q!=lines[distribute[sparsity.get_column_numbers()[j]]]
+                                       .entries.size(); ++q)
+                     uncondensed.add (lines[distribute[row]].entries[p].first,
+                                      lines[distribute[sparsity.get_column_numbers()[j]]]
+                                      .entries[q].first,
+                                      uncondensed.global_entry(j) *
+                                      lines[distribute[row]].entries[p].second *
+                                      lines[distribute[sparsity.get_column_numbers()[j]]]
+                                      .entries[q].second);
+               
+                 uncondensed.global_entry(j) = (row == sparsity.get_column_numbers()[j] ?
+                                                1. : 0. );
+               };
+           };
     };
 };
 
index 5ea73946f1ae24bc13d680a3058a0a990be3ba07..88667c5176530d7c0f1c52ef166764e0bbdf8efd 100644 (file)
@@ -301,6 +301,96 @@ DoFHandler<1>::last_active_quad () const {
   return 0;
 };
 
+
+
+template <>
+DoFHandler<1>::raw_hex_iterator
+DoFHandler<1>::begin_raw_hex (unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<1>::hex_iterator
+DoFHandler<1>::begin_hex (unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<1>::active_hex_iterator
+DoFHandler<1>::begin_active_hex (unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<1>::raw_hex_iterator
+DoFHandler<1>::end_hex () const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<1>::raw_hex_iterator
+DoFHandler<1>::last_raw_hex (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<1>::raw_hex_iterator
+DoFHandler<1>::last_raw_hex () const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<1>::hex_iterator
+DoFHandler<1>::last_hex (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<1>::hex_iterator
+DoFHandler<1>::last_hex () const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<1>::active_hex_iterator
+DoFHandler<1>::last_active_hex (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<1>::active_hex_iterator
+DoFHandler<1>::last_active_hex () const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
 #endif
 
 
@@ -463,11 +553,272 @@ DoFHandler<2>::last_active_face (const unsigned int level) const {
   return last_active_line (level);
 };
 
+
+
+template <>
+DoFHandler<2>::raw_hex_iterator
+DoFHandler<2>::begin_raw_hex (unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<2>::hex_iterator
+DoFHandler<2>::begin_hex (unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<2>::active_hex_iterator
+DoFHandler<2>::begin_active_hex (unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<2>::raw_hex_iterator
+DoFHandler<2>::end_hex () const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<2>::raw_hex_iterator
+DoFHandler<2>::last_raw_hex (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<2>::raw_hex_iterator
+DoFHandler<2>::last_raw_hex () const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<2>::hex_iterator
+DoFHandler<2>::last_hex (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<2>::hex_iterator
+DoFHandler<2>::last_hex () const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<2>::active_hex_iterator
+DoFHandler<2>::last_active_hex (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+DoFHandler<2>::active_hex_iterator
+DoFHandler<2>::last_active_hex () const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
 #endif
 
 
 
 
+
+#if deal_II_dimension == 3
+
+template <>
+DoFHandler<3>::raw_cell_iterator
+DoFHandler<3>::begin_raw (const unsigned int level) const {
+  return begin_raw_hex (level);
+};
+
+
+
+template <>
+DoFHandler<3>::cell_iterator
+DoFHandler<3>::begin (const unsigned int level) const {
+  return begin_hex (level);
+};
+
+
+
+template <>
+DoFHandler<3>::active_cell_iterator
+DoFHandler<3>::begin_active (const unsigned int level) const {
+  return begin_active_hex (level);
+};
+
+
+
+template <>
+DoFHandler<3>::raw_cell_iterator
+DoFHandler<3>::end () const {
+  return end_hex ();
+};
+
+
+
+template <>
+DoFHandler<3>::raw_cell_iterator
+DoFHandler<3>::last_raw () const {
+  return last_raw_hex ();
+};
+
+
+
+template <>
+DoFHandler<3>::raw_cell_iterator
+DoFHandler<3>::last_raw (const unsigned int level) const {
+  return last_raw_hex (level);
+};
+
+
+
+template <>
+DoFHandler<3>::cell_iterator
+DoFHandler<3>::last () const {
+  return last_hex ();
+};
+
+
+
+template <>
+DoFHandler<3>::cell_iterator
+DoFHandler<3>::last (const unsigned int level) const {
+  return last_hex (level);
+};
+
+
+
+template <>
+DoFHandler<3>::active_cell_iterator
+DoFHandler<3>::last_active () const {
+  return last_active_hex ();
+};
+
+
+
+template <>
+DoFHandler<3>::active_cell_iterator
+DoFHandler<3>::last_active (const unsigned int level) const {
+  return last_active_hex (level);
+};
+
+
+
+
+
+
+
+template <>
+DoFHandler<3>::raw_face_iterator
+DoFHandler<3>::begin_raw_face (const unsigned int level) const {
+  return begin_raw_quad (level);
+};
+
+
+
+template <>
+DoFHandler<3>::face_iterator
+DoFHandler<3>::begin_face (const unsigned int level) const {
+  return begin_quad (level);
+};
+
+
+
+template <>
+DoFHandler<3>::active_face_iterator
+DoFHandler<3>::begin_active_face (const unsigned int level) const {
+  return begin_active_quad (level);
+};
+
+
+
+template <>
+DoFHandler<3>::raw_face_iterator
+DoFHandler<3>::end_face () const {
+  return end_quad ();
+};
+
+
+
+template <>
+DoFHandler<3>::raw_face_iterator
+DoFHandler<3>::last_raw_face () const {
+  return last_raw_quad ();
+};
+
+
+
+template <>
+DoFHandler<3>::raw_face_iterator
+DoFHandler<3>::last_raw_face (const unsigned int level) const {
+  return last_raw_quad (level);
+};
+
+
+
+template <>
+DoFHandler<3>::face_iterator
+DoFHandler<3>::last_face () const {
+  return last_quad ();
+};
+
+
+
+template <>
+DoFHandler<3>::face_iterator
+DoFHandler<3>::last_face (const unsigned int level) const {
+  return last_quad (level);
+};
+
+
+
+template <>
+DoFHandler<3>::active_face_iterator
+DoFHandler<3>::last_active_face () const {
+  return last_active_quad ();
+};
+
+
+
+template <>
+DoFHandler<3>::active_face_iterator
+DoFHandler<3>::last_active_face (const unsigned int level) const {
+  return last_active_quad (level);
+};
+
+
+#endif
+
+
+
 template <int dim>
 typename DoFHandler<dim>::raw_line_iterator
 DoFHandler<dim>::begin_raw_line (const unsigned int level) const {
@@ -534,6 +885,40 @@ DoFHandler<dim>::begin_active_quad (const unsigned int level) const {
 
 
 
+
+template <int dim>
+typename DoFHandler<dim>::raw_hex_iterator
+DoFHandler<dim>::begin_raw_hex (const unsigned int level) const {
+  return raw_hex_iterator (tria,
+                          tria->begin_raw_hex(level)->level(),
+                          tria->begin_raw_hex(level)->index(),
+                          this);
+};
+
+
+
+template <int dim>
+typename DoFHandler<dim>::hex_iterator
+DoFHandler<dim>::begin_hex (const unsigned int level) const {
+  return hex_iterator (tria,
+                      tria->begin_hex(level)->level(),
+                      tria->begin_hex(level)->index(),
+                      this);
+};
+
+
+
+template <int dim>
+typename DoFHandler<dim>::active_hex_iterator
+DoFHandler<dim>::begin_active_hex (const unsigned int level) const {
+  return active_hex_iterator (tria,
+                             tria->begin_active_hex(level)->level(),
+                             tria->begin_active_hex(level)->index(),
+                             this);
+};
+
+
+
 template <int dim>
 typename DoFHandler<dim>::raw_line_iterator
 DoFHandler<dim>::end_line () const {
@@ -550,6 +935,14 @@ DoFHandler<dim>::end_quad () const {
 
 
 
+template <int dim>
+typename DoFHandler<dim>::raw_hex_iterator
+DoFHandler<dim>::end_hex () const {
+  return raw_hex_iterator (tria, -1, -1, this);
+};
+
+
+
 template <int dim>
 typename DoFDimensionInfo<dim>::raw_cell_iterator
 DoFHandler<dim>::end_raw (const unsigned int level) const {
@@ -671,6 +1064,36 @@ DoFHandler<dim>::end_active_quad (const unsigned int level) const {
 
 
 
+template <int dim>
+typename DoFDimensionInfo<dim>::raw_hex_iterator
+DoFHandler<dim>::end_raw_hex (const unsigned int level) const {
+  return (level == levels.size()-1 ?
+         end_hex() :
+         begin_raw_hex (level+1));
+};
+
+
+
+template <int dim>
+typename DoFDimensionInfo<dim>::hex_iterator
+DoFHandler<dim>::end_hex (const unsigned int level) const {
+  return (level == levels.size()-1 ?
+         hex_iterator(end_hex()) :
+         begin_hex (level+1));
+};
+
+
+
+template <int dim>
+typename DoFDimensionInfo<dim>::active_hex_iterator
+DoFHandler<dim>::end_active_hex (const unsigned int level) const {
+  return (level == levels.size()-1 ?
+         active_hex_iterator(end_hex()) :
+         begin_active_hex (level+1));
+};
+
+
+
 template <int dim>
 typename DoFHandler<dim>::raw_line_iterator
 DoFHandler<dim>::last_raw_line (const unsigned int level) const {
@@ -717,29 +1140,63 @@ DoFHandler<dim>::last_raw_quad (const unsigned int level) const {
 
 
 template <int dim>
-typename DoFHandler<dim>::quad_iterator
-DoFHandler<dim>::last_quad (const unsigned int level) const {
-  return quad_iterator (tria,
-                       tria->last_quad(level)->level(),
-                       tria->last_quad(level)->index(),
-                       this);
+typename DoFHandler<dim>::quad_iterator
+DoFHandler<dim>::last_quad (const unsigned int level) const {
+  return quad_iterator (tria,
+                       tria->last_quad(level)->level(),
+                       tria->last_quad(level)->index(),
+                       this);
+};
+
+
+
+
+template <int dim>
+typename DoFHandler<dim>::active_quad_iterator
+DoFHandler<dim>::last_active_quad (const unsigned int level) const {
+  return active_quad_iterator (tria,
+                              tria->last_active_quad(level)->level(),
+                              tria->last_active_quad(level)->index(),
+                              this);
+};
+
+
+
+template <int dim>
+typename DoFHandler<dim>::raw_hex_iterator
+DoFHandler<dim>::last_raw_hex (const unsigned int level) const {
+  return raw_hex_iterator (tria,
+                          tria->last_raw_hex(level)->level(),
+                          tria->last_raw_hex(level)->index(),
+                          this);
+};
+
+
+
+
+template <int dim>
+typename DoFHandler<dim>::hex_iterator
+DoFHandler<dim>::last_hex (const unsigned int level) const {
+  return hex_iterator (tria,
+                      tria->last_hex(level)->level(),
+                      tria->last_hex(level)->index(),
+                      this);
 };
 
 
 
 
 template <int dim>
-typename DoFHandler<dim>::active_quad_iterator
-DoFHandler<dim>::last_active_quad (const unsigned int level) const {
-  return active_quad_iterator (tria,
-                              tria->last_active_quad(level)->level(),
-                              tria->last_active_quad(level)->index(),
-                              this);
+typename DoFHandler<dim>::active_hex_iterator
+DoFHandler<dim>::last_active_hex (const unsigned int level) const {
+  return active_hex_iterator (tria,
+                             tria->last_active_hex(level)->level(),
+                             tria->last_active_hex(level)->index(),
+                             this);
 };
 
 
 
-
 template <int dim>
 typename DoFHandler<dim>::raw_line_iterator
 DoFHandler<dim>::last_raw_line () const {
@@ -756,6 +1213,14 @@ DoFHandler<dim>::last_raw_quad () const {
 
 
 
+template <int dim>
+typename DoFHandler<dim>::raw_hex_iterator
+DoFHandler<dim>::last_raw_hex () const {
+  return last_raw_hex (levels.size()-1);
+};
+
+
+
 template <int dim>
 typename DoFHandler<dim>::line_iterator
 DoFHandler<dim>::last_line () const {
@@ -772,6 +1237,14 @@ DoFHandler<dim>::last_quad () const {
 
 
 
+template <int dim>
+typename DoFHandler<dim>::hex_iterator
+DoFHandler<dim>::last_hex () const {
+  return last_hex (levels.size()-1);
+};
+
+
+
 template <int dim>
 typename DoFHandler<dim>::active_line_iterator
 DoFHandler<dim>::last_active_line () const {
@@ -780,7 +1253,6 @@ DoFHandler<dim>::last_active_line () const {
 
 
 
-
 template <int dim>
 typename DoFHandler<dim>::active_quad_iterator
 DoFHandler<dim>::last_active_quad () const {
@@ -789,6 +1261,14 @@ DoFHandler<dim>::last_active_quad () const {
 
 
 
+template <int dim>
+typename DoFHandler<dim>::active_hex_iterator
+DoFHandler<dim>::last_active_hex () const {
+  return last_active_hex (levels.size()-1);
+};
+
+
+
 
 
 
@@ -1022,6 +1502,68 @@ unsigned int DoFHandler<2>::distribute_dofs_on_cell (active_cell_iterator &cell,
 
 
 
+#if deal_II_dimension == 3
+
+template <>
+unsigned int DoFHandler<3>::distribute_dofs_on_cell (active_cell_iterator &cell,
+                                                    unsigned int          next_free_dof) {
+  if (selected_fe->dofs_per_vertex > 0)
+                                    // number dofs on vertices
+    for (unsigned int vertex=0; vertex<GeometryInfo<3>::vertices_per_cell; ++vertex)
+                                      // check whether dofs for this
+                                      // vertex have been distributed
+                                      // (only check the first dof)
+      if (cell->vertex_dof_index(vertex, 0) == -1)
+       for (unsigned int d=0; d<selected_fe->dofs_per_vertex; ++d)
+         cell->set_vertex_dof_index (vertex, d, next_free_dof++);
+    
+                                  // for the lines
+  if (selected_fe->dofs_per_line > 0)
+    for (unsigned int l=0; l<GeometryInfo<3>::lines_per_cell; ++l)
+      {
+       line_iterator line = cell->line(l);
+       
+                                        // distribute dofs if necessary:
+                                        // check whether line dof is already
+                                        // numbered (check only first dof)
+       if (line->dof_index(0) == -1)
+                                          // if not: distribute dofs
+         for (unsigned int d=0; d<selected_fe->dofs_per_line; ++d)
+           line->set_dof_index (d, next_free_dof++);       
+      };
+
+                                  // for the quads
+  if (selected_fe->dofs_per_quad > 0)
+    for (unsigned int q=0; q<GeometryInfo<3>::quads_per_cell; ++q)
+      {
+       quad_iterator quad = cell->quad(q);
+       
+                                        // distribute dofs if necessary:
+                                        // check whether quad dof is already
+                                        // numbered (check only first dof)
+       if (quad->dof_index(0) == -1)
+                                          // if not: distribute dofs
+         for (unsigned int d=0; d<selected_fe->dofs_per_quad; ++d)
+           quad->set_dof_index (d, next_free_dof++);       
+      };
+
+
+                                      // dofs of hex
+  if (selected_fe->dofs_per_hex > 0)
+    for (unsigned int d=0; d<selected_fe->dofs_per_hex; ++d)
+      cell->set_dof_index (d, next_free_dof++);
+
+  
+                                  // note that this cell has been processed
+  cell->set_user_flag ();
+  
+  return next_free_dof;
+};
+
+#endif
+
+
+
 template <int dim>
 void DoFHandler<dim>::renumber_dofs (const RenumberingMethod method,
                                     const bool use_constraints,
@@ -1037,17 +1579,10 @@ void DoFHandler<dim>::renumber_dofs (const RenumberingMethod method,
       constraints.condense (sparsity);
     };
     
-  int total_dofs = sparsity.n_rows();
+  int n_dofs = sparsity.n_rows();
                                   // store the new dof numbers; -1 means
                                   // that no new number was chosen yet
-                                  //
-                                  // the commented line is what would be the
-                                  // correct way to do, but gcc2.8 chokes
-                                  // over that. The other lines are a
-                                  // workaround
-//  vector<int> new_number(sparsity.n_rows(), -1);
-  vector<int> new_number;
-  new_number.resize (sparsity.n_rows(), -1);
+  vector<int> new_number(sparsity.n_rows(), -1);
   
                                   // store the indices of the dofs renumbered
                                   // in the last round. Default to starting
@@ -1056,7 +1591,7 @@ void DoFHandler<dim>::renumber_dofs (const RenumberingMethod method,
   
                                   // delete disallowed elements
   for (unsigned int i=0; i<last_round_dofs.size(); ++i)
-    if ((last_round_dofs[i]<0) || (last_round_dofs[i]>=total_dofs))
+    if ((last_round_dofs[i]<0) || (last_round_dofs[i]>=n_dofs))
       last_round_dofs[i] = -1;
   
   remove_if (last_round_dofs.begin(), last_round_dofs.end(),
@@ -1069,8 +1604,8 @@ void DoFHandler<dim>::renumber_dofs (const RenumberingMethod method,
   if (last_round_dofs.size() == 0)
     {
       int          starting_point   = -1;
-      unsigned int min_coordination = total_dofs;
-      for (int row=0; row<total_dofs; ++row) 
+      unsigned int min_coordination = n_dofs;
+      for (int row=0; row<n_dofs; ++row) 
        {
          unsigned int j;
          for (j=sparsity.get_rowstart_indices()[row];
@@ -1179,7 +1714,7 @@ void DoFHandler<dim>::renumber_dofs (const RenumberingMethod method,
                                   //  test for all indices numbered
   if (find (new_number.begin(), new_number.end(), -1) != new_number.end())
     Assert (false, ExcRenumberingIncomplete());
-  Assert (next_free_number == total_dofs,
+  Assert (next_free_number == n_dofs,
          ExcRenumberingIncomplete());
 #endif
 
@@ -1190,7 +1725,7 @@ void DoFHandler<dim>::renumber_dofs (const RenumberingMethod method,
       case reverse_Cuthill_McKee:
       {
        for (vector<int>::iterator i=new_number.begin(); i!=new_number.end(); ++i)
-         *i = total_dofs-*i;
+         *i = n_dofs-*i;
        break;
       };
       default:
@@ -1305,6 +1840,64 @@ void DoFHandler<2>::renumber_dofs (const vector<int> &new_numbers) {
 #endif
 
 
+#if deal_II_dimension == 3
+
+template <>
+void DoFHandler<3>::renumber_dofs (const vector<int> &new_numbers) {
+  Assert (new_numbers.size() == n_dofs(), ExcRenumberingIncomplete());
+#ifdef DEBUG
+                                  // assert that the new indices are
+                                  // consecutively numbered
+  if (true)
+    {
+      vector<int> tmp(new_numbers);
+      sort (tmp.begin(), tmp.end());
+      vector<int>::const_iterator p = tmp.begin();
+      int                         i = 0;
+      for (; p!=tmp.end(); ++p, ++i)
+       Assert (*p == i, ExcNewNumbersNotConsecutive(i));
+    };
+#endif
+
+                                  // note that we can not use cell iterators
+                                  // in this function since then we would
+                                  // renumber the dofs on the interface of
+                                  // two cells more than once. Anyway, this
+                                  // way it's not only more correct but also
+                                  // faster; note, however, that dof numbers
+                                  // may be -1, namely when the appropriate
+                                  // vertex/line/etc is unused
+  for (vector<int>::iterator i=vertex_dofs.begin(); i!=vertex_dofs.end(); ++i)
+    if (*i != -1)
+      *i = new_numbers[*i];
+    else
+                                      // if index is -1: check if this one
+                                      // really is unused
+      Assert (tria->vertices_used[(i-vertex_dofs.begin()) /
+                                selected_fe->dofs_per_vertex] == false,
+             ExcInternalError ());
+  
+  for (unsigned int level=0; level<levels.size(); ++level) 
+    {
+      for (vector<int>::iterator i=levels[level]->line_dofs.begin();
+          i!=levels[level]->line_dofs.end(); ++i)
+       if (*i != -1)
+         *i = new_numbers[*i];
+      for (vector<int>::iterator i=levels[level]->quad_dofs.begin();
+          i!=levels[level]->quad_dofs.end(); ++i)
+       if (*i != -1)
+         *i = new_numbers[*i];
+      for (vector<int>::iterator i=levels[level]->hex_dofs.begin();
+          i!=levels[level]->hex_dofs.end(); ++i)
+       if (*i != -1)
+         *i = new_numbers[*i];
+    };
+};
+
+#endif
+
+
+
 #if deal_II_dimension == 1
 
 template <>
@@ -1409,6 +2002,163 @@ void DoFHandler<2>::make_constraint_matrix (ConstraintMatrix &constraints) const
 
 
 
+#if deal_II_dimension == 3
+
+template <>
+void DoFHandler<3>::make_constraint_matrix (ConstraintMatrix &constraints) const {
+  const unsigned int dim = 3;
+  
+  constraints.clear ();
+
+                                  // first mark all faces which are subject
+                                  // to constraints. We do so by looping
+                                  // over all active cells and checking
+                                  // whether any of the faces are refined
+                                  // which can only be from the neighboring
+                                  // cell because this one is active. In that
+                                  // case, the face is subject to constraints
+  tria->clear_user_flags ();
+  Triangulation<dim>::active_cell_iterator cell = tria->begin_active(),
+                                          endc = tria->end();
+  for (; cell!=endc; ++cell)
+    for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+      if (cell->face(face)->has_children()) 
+       cell->face(face)->set_user_flag();
+         
+  
+
+  
+  face_iterator face = begin_face(),
+               endf = end_face();
+                                  // loop over all faces; only on faces
+                                  // there can be constraints.
+  for (; face != endf; ++face)
+                                    // if dofs on this line are subject
+                                    // to constraints
+    if (face->user_flag_set() == true)
+      {
+                                        // reserve space to gather
+                                        // the dof numbers. We could
+                                        // get them when we need them,
+                                        // but it seems easier to gather
+                                        // them only once.
+       vector<int> dofs_on_mother;
+       vector<int> dofs_on_children;
+       dofs_on_mother.reserve (4*selected_fe->dofs_per_vertex+
+                               4*selected_fe->dofs_per_line+
+                               selected_fe->dofs_per_quad);
+       dofs_on_children.reserve (5*selected_fe->dofs_per_vertex+
+                                 12*selected_fe->dofs_per_line+
+                                 4*selected_fe->dofs_per_quad);
+
+       Assert(4*selected_fe->dofs_per_vertex+
+              4*selected_fe->dofs_per_line+
+              selected_fe->dofs_per_quad
+              ==
+              selected_fe->constraints().n(),
+              ExcDifferentDimensions(4*selected_fe->dofs_per_vertex+
+                                     4*selected_fe->dofs_per_line+
+                                     selected_fe->dofs_per_quad,
+                                     selected_fe->constraints().n()));
+       Assert(5*selected_fe->dofs_per_vertex+
+              12*selected_fe->dofs_per_line+
+              4*selected_fe->dofs_per_quad
+              ==
+              selected_fe->constraints().m(),
+              ExcDifferentDimensions(5*selected_fe->dofs_per_vertex+
+                                     12*selected_fe->dofs_per_line+
+                                     4*selected_fe->dofs_per_quad,
+                                     selected_fe->constraints().m()));
+       
+                                        // fill the dofs indices. Use same
+                                        // enumeration scheme as in
+                                        // #FiniteElement::constraints()#
+       for (unsigned int vertex=0; vertex<4; ++vertex)
+         for (unsigned int dof=0; dof!=selected_fe->dofs_per_vertex; ++dof)
+           dofs_on_mother.push_back (face->vertex_dof_index(vertex,dof));
+       for (unsigned int line=0; line<4; ++line)
+         for (unsigned int dof=0; dof!=selected_fe->dofs_per_line; ++dof)
+           dofs_on_mother.push_back (face->line(line)->dof_index(dof));
+       for (unsigned int dof=0; dof!=selected_fe->dofs_per_quad; ++dof)
+         dofs_on_mother.push_back (face->dof_index(dof));
+
+                                        // dof numbers on vertex at the center
+                                        // of the face, which is vertex 2 of
+                                        // child zero, or vertex 3 of child 1
+                                        // or vertex 0 of child 2 or vertex 1
+                                        // of child 3. We're a bit cautious and
+                                        // check this (also an additional safety
+                                        // check for the internal states of the
+                                        // library)
+       Assert ((face->child(0)->vertex_dof_index(2,0) ==
+                face->child(1)->vertex_dof_index(3,0)) &&
+               (face->child(0)->vertex_dof_index(2,0) ==
+                face->child(2)->vertex_dof_index(0,0)) &&
+               (face->child(0)->vertex_dof_index(2,0) ==
+                face->child(3)->vertex_dof_index(1,0)),
+               ExcInternalError());
+       for (unsigned int dof=0; dof!=selected_fe->dofs_per_vertex; ++dof)
+         dofs_on_children.push_back (face->child(0)->vertex_dof_index(2,dof));
+       
+                                        // dof numbers on the centers of
+                                        // the lines bounding this face
+       for (unsigned int line=0; line<4; ++line)
+         for (unsigned int dof=0; dof!=selected_fe->dofs_per_vertex; ++dof)
+           dofs_on_children.push_back (face->line(line)->child(0)->vertex_dof_index(1,dof));
+
+                                        // next the dofs on the lines interior
+                                        // to the face; the order of these
+                                        // lines is laid down in the
+                                        // FiniteElement class documentation
+       for (unsigned int dof=0; dof<selected_fe->dofs_per_line; ++dof)
+         dofs_on_children.push_back (face->child(0)->line(1)->dof_index(dof));
+       for (unsigned int dof=0; dof<selected_fe->dofs_per_line; ++dof)
+         dofs_on_children.push_back (face->child(1)->line(2)->dof_index(dof));
+       for (unsigned int dof=0; dof<selected_fe->dofs_per_line; ++dof)
+         dofs_on_children.push_back (face->child(2)->line(3)->dof_index(dof));
+       for (unsigned int dof=0; dof<selected_fe->dofs_per_line; ++dof)
+         dofs_on_children.push_back (face->child(3)->line(0)->dof_index(dof));
+
+                                        // dofs on the bordering lines
+       for (unsigned int line=0; line<4; ++line)
+         for (unsigned int child=0; child<2; ++child)
+           for (unsigned int dof=0; dof!=selected_fe->dofs_per_line; ++dof)
+             dofs_on_children.push_back (face->line(line)->child(child)->dof_index(dof));
+       
+                                        // finally, for the dofs interior
+                                        // to the four child faces
+       for (unsigned int child=0; child<4; ++child)
+         for (unsigned int dof=0; dof!=selected_fe->dofs_per_quad; ++dof)
+           dofs_on_children.push_back (face->child(child)->dof_index(dof));
+
+       Assert (dofs_on_children.size() ==
+              selected_fe->constraints().m(),
+              ExcDifferentDimensions(dofs_on_children.size(),
+                                     selected_fe->constraints().m()));
+       Assert (dofs_on_mother.size() ==
+              selected_fe->constraints().n(),
+              ExcDifferentDimensions(dofs_on_mother.size(),
+                                     selected_fe->constraints().n()));
+
+                                        // for each row in the constraint
+                                        // matrix for this line:
+       for (unsigned int row=0; row!=dofs_on_children.size(); ++row) 
+         {
+           constraints.add_line (dofs_on_children[row]);
+           for (unsigned int i=0; i!=dofs_on_mother.size(); ++i)
+             constraints.add_entry (dofs_on_children[row],
+                                    dofs_on_mother[i],
+                                    selected_fe->constraints()(row,i));
+         };
+      };
+
+  constraints.close ();
+};
+
+#endif
+
+
+
 template <int dim>
 void DoFHandler<dim>::make_sparsity_pattern (dSMatrixStruct &sparsity) const {
   Assert (selected_fe != 0, ExcNoFESelected());
@@ -1880,6 +2630,60 @@ unsigned int DoFHandler<2>::max_transfer_entries (const unsigned int max_level_d
 #endif
 
 
+#if deal_II_dimension == 3
+
+template <>
+unsigned int DoFHandler<3>::max_couplings_between_dofs () const {
+  Assert (selected_fe != 0, ExcNoFESelected());
+
+                                  // doing the same thing here is a rather
+                                  // complicated thing, compared to the 2d
+                                  // case, since it is hard to draw pictures
+                                  // with several refined hexahedra :-) so I
+                                  // presently only give a coarse estimate
+                                  // for the case that at most 8 hexes meet
+                                  // at each vertex
+                                  //
+                                  // can anyone give better estimate here?
+  const unsigned int max_adjacent_cells = tria->max_adjacent_cells();
+
+  if (max_adjacent_cells <= 8)
+    return (7*7*7*selected_fe->dofs_per_vertex +
+           7*6*7*3*selected_fe->dofs_per_line +
+           9*4*7*3*selected_fe->dofs_per_quad +
+           27*selected_fe->dofs_per_hex);
+
+  
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+
+
+template <>
+unsigned int DoFHandler<3>::max_couplings_between_boundary_dofs () const {
+  Assert (selected_fe != 0, ExcNoFESelected());
+                                  // we need to take refinement of
+                                  // one boundary face into consideration
+                                  // here; in fact, this function returns
+                                  // what #max_coupling_between_dofs<2>
+                                  // returns
+                                  //
+                                  // we assume here, that only four faces
+                                  // meet at the boundary; this assumption
+                                  // is not justified and needs to be
+                                  // fixed some time. fortunately, ommitting
+                                  // it for now does no harm since the
+                                  // matrix will cry foul if its requirements
+                                  // are not satisfied
+  return (19*selected_fe->dofs_per_vertex +
+         28*selected_fe->dofs_per_line +
+         8*selected_fe->dofs_per_quad);
+};
+
+
+
+#endif
 
 
 
@@ -2075,6 +2879,41 @@ void DoFHandler<2>::reserve_space () {
 #endif
 
 
+#if deal_II_dimension == 3
+
+template <>
+void DoFHandler<3>::reserve_space () {
+  Assert (selected_fe != 0, ExcNoFESelected());
+  Assert (tria->n_levels() > 0, ExcInvalidTriangulation());
+  
+                                   // delete all levels and set them up
+                                   // newly, since vectors are
+                                   // troublesome if you want to change
+                                   // their size
+  clear_space ();
+  
+  vertex_dofs = vector<int>(tria->vertices.size()*
+                           selected_fe->dofs_per_vertex,
+                           -1);
+  for (unsigned int i=0; i<tria->n_levels(); ++i) 
+    {
+      levels.push_back (new DoFLevel<3>);
+
+      levels.back()->line_dofs = vector<int> (tria->levels[i]->lines.lines.size() *
+                                             selected_fe->dofs_per_line,
+                                             -1);
+      levels.back()->quad_dofs = vector<int> (tria->levels[i]->quads.quads.size() *
+                                             selected_fe->dofs_per_quad,
+                                             -1);
+      levels.back()->hex_dofs = vector<int> (tria->levels[i]->hexes.hexes.size() *
+                                            selected_fe->dofs_per_hex,
+                                            -1);
+    };
+};
+
+#endif
+
+
 template <int dim>
 void DoFHandler<dim>::clear_space () {  
   for (unsigned int i=0; i<levels.size(); ++i)
index ce0a9290e51ac36413b77dd9dc940ace6d3c2605..90eaa5e2f20e63581ccd6f83b561948b91959be8 100644 (file)
@@ -46,6 +46,8 @@ FiniteElementData<dim>::FiniteElementData (const unsigned int dofs_per_vertex,
   Assert(dim==3, ExcDimensionMismatch(3,dim));
 };
 
+
+
 template <int dim>
 FiniteElementData<dim>::FiniteElementData (const unsigned int dofs_per_vertex,
                                           const unsigned int dofs_per_line,
@@ -70,6 +72,8 @@ FiniteElementData<dim>::FiniteElementData (const unsigned int dofs_per_vertex,
   Assert(dim==2, ExcDimensionMismatch(2,dim));
 };
 
+
+
 template <int dim>
 FiniteElementData<dim>::FiniteElementData (const unsigned int dofs_per_vertex,
                                           const unsigned int dofs_per_line,
@@ -106,7 +110,7 @@ FiniteElementData<dim>::FiniteElementData (const unsigned int dofs_per_vertex,
 
 
 template<int dim>
-bool FiniteElementData<dim>::operator== (const FiniteElementData<2> &f) const
+bool FiniteElementData<dim>::operator== (const FiniteElementData<dim> &f) const
 {
   return ((dofs_per_vertex == f.dofs_per_vertex) &&
          (dofs_per_line == f.dofs_per_line) &&
@@ -137,6 +141,10 @@ FiniteElementBase<1>::FiniteElementBase (const FiniteElementData<1> &fe_data) :
   interface_constraints.reinit (1,1);
   interface_constraints(0,0)=1.;
 
+                                  // this is the default way, if there is only
+                                  // one component; if there are several, then
+                                  // the constructor of the derived class needs
+                                  // to fill these arrays
   for (unsigned int j=0 ; j<total_dofs ; ++j)
     {
       system_to_component_table[j] = pair<unsigned,unsigned>(0,j);
@@ -162,7 +170,44 @@ FiniteElementBase<2>::FiniteElementBase (const FiniteElementData<2> &fe_data) :
       prolongation[i].reinit (total_dofs, total_dofs);
     };
   interface_constraints.reinit (dofs_per_vertex+2*dofs_per_line,
-                               2*dofs_per_vertex+dofs_per_line);
+                               dofs_per_face);
+
+                                  // this is the default way, if there is only
+                                  // one component; if there are several, then
+                                  // the constructor of the derived class needs
+                                  // to fill these arrays
+  for (unsigned int j=0 ; j<total_dofs ; ++j)
+    {
+      system_to_component_table[j] = pair<unsigned,unsigned>(0,j);
+      component_to_system_table[0][j] = j;
+    }
+};
+
+#endif
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+FiniteElementBase<3>::FiniteElementBase (const FiniteElementData<3> &fe_data) :
+               FiniteElementData<3> (fe_data),
+               system_to_component_table(total_dofs),
+               component_to_system_table(n_components, vector<unsigned>(total_dofs))
+{
+  const unsigned int dim=3;
+  for (unsigned int i=0; i<GeometryInfo<dim>::children_per_cell; ++i) 
+    {
+      restriction[i].reinit (total_dofs, total_dofs);
+      prolongation[i].reinit (total_dofs, total_dofs);
+    };
+  interface_constraints.reinit (5*dofs_per_vertex+12*dofs_per_line+4*dofs_per_quad,
+                               dofs_per_face);
+
+                                  // this is the default way, if there is only
+                                  // one component; if there are several, then
+                                  // the constructor of the derived class needs
+                                  // to fill these arrays
   for (unsigned int j=0 ; j<total_dofs ; ++j)
     {
       system_to_component_table[j] = pair<unsigned,unsigned>(0,j);
index 5b1fef0987765f5730723eac5f5b7fa7708e7555..ca55db78f4253a87d6122ee4ad2d6c83bbf16426 100644 (file)
@@ -1602,7 +1602,10304 @@ void FECubicSub<2>::get_face_support_points (const typename DoFHandler<2>::face_
 
 
 
+#if 0   // ignore the following, since it doesn't compile properly. it simply
+                                // is too large
 
+#if deal_II_dimension == 3
+
+template <>
+FECubicSub<3>::FECubicSub () :
+               FELinearMapping<3> (1, 2, 4, 8)
+{
+      interface_constraints(0,0) = 1.0/256.0;
+      interface_constraints(0,1) = 1.0/256.0;
+      interface_constraints(0,2) = 1.0/256.0;
+      interface_constraints(0,3) = 1.0/256.0;
+      interface_constraints(0,4) = -9.0/256.0;
+      interface_constraints(0,5) = -9.0/256.0;
+      interface_constraints(0,6) = -9.0/256.0;
+      interface_constraints(0,7) = -9.0/256.0;
+      interface_constraints(0,8) = -9.0/256.0;
+      interface_constraints(0,9) = -9.0/256.0;
+      interface_constraints(0,10) = -9.0/256.0;
+      interface_constraints(0,11) = -9.0/256.0;
+      interface_constraints(0,12) = 81.0/256.0;
+      interface_constraints(0,13) = 81.0/256.0;
+      interface_constraints(0,14) = 81.0/256.0;
+      interface_constraints(0,15) = 81.0/256.0;
+      interface_constraints(1,0) = -1.0/16.0;
+      interface_constraints(1,1) = -1.0/16.0;
+      interface_constraints(1,4) = 9.0/16.0;
+      interface_constraints(1,5) = 9.0/16.0;
+      interface_constraints(2,1) = -1.0/16.0;
+      interface_constraints(2,2) = -1.0/16.0;
+      interface_constraints(2,6) = 9.0/16.0;
+      interface_constraints(2,7) = 9.0/16.0;
+      interface_constraints(3,2) = -1.0/16.0;
+      interface_constraints(3,3) = -1.0/16.0;
+      interface_constraints(3,8) = 9.0/16.0;
+      interface_constraints(3,9) = 9.0/16.0;
+      interface_constraints(4,0) = -1.0/16.0;
+      interface_constraints(4,3) = -1.0/16.0;
+      interface_constraints(4,10) = 9.0/16.0;
+      interface_constraints(4,11) = 9.0/16.0;
+      interface_constraints(5,0) = -5.0/256.0;
+      interface_constraints(5,1) = -5.0/256.0;
+      interface_constraints(5,2) = -1.0/256.0;
+      interface_constraints(5,3) = -1.0/256.0;
+      interface_constraints(5,4) = 45.0/256.0;
+      interface_constraints(5,5) = 45.0/256.0;
+      interface_constraints(5,6) = -15.0/256.0;
+      interface_constraints(5,7) = 5.0/256.0;
+      interface_constraints(5,8) = 9.0/256.0;
+      interface_constraints(5,9) = 9.0/256.0;
+      interface_constraints(5,10) = -15.0/256.0;
+      interface_constraints(5,11) = 5.0/256.0;
+      interface_constraints(5,12) = 135.0/256.0;
+      interface_constraints(5,13) = 135.0/256.0;
+      interface_constraints(5,14) = -45.0/256.0;
+      interface_constraints(5,15) = -45.0/256.0;
+      interface_constraints(6,6) = -1.0/16.0;
+      interface_constraints(6,10) = -1.0/16.0;
+      interface_constraints(6,12) = 9.0/16.0;
+      interface_constraints(6,13) = 9.0/16.0;
+      interface_constraints(7,5) = -1.0/16.0;
+      interface_constraints(7,9) = -1.0/16.0;
+      interface_constraints(7,13) = 9.0/16.0;
+      interface_constraints(7,15) = 9.0/16.0;
+      interface_constraints(8,0) = -1.0/256.0;
+      interface_constraints(8,1) = -5.0/256.0;
+      interface_constraints(8,2) = -5.0/256.0;
+      interface_constraints(8,3) = -1.0/256.0;
+      interface_constraints(8,4) = 5.0/256.0;
+      interface_constraints(8,5) = -15.0/256.0;
+      interface_constraints(8,6) = 45.0/256.0;
+      interface_constraints(8,7) = 45.0/256.0;
+      interface_constraints(8,8) = 5.0/256.0;
+      interface_constraints(8,9) = -15.0/256.0;
+      interface_constraints(8,10) = 9.0/256.0;
+      interface_constraints(8,11) = 9.0/256.0;
+      interface_constraints(8,12) = -45.0/256.0;
+      interface_constraints(8,13) = 135.0/256.0;
+      interface_constraints(8,14) = -45.0/256.0;
+      interface_constraints(8,15) = 135.0/256.0;
+      interface_constraints(9,7) = -1.0/16.0;
+      interface_constraints(9,11) = -1.0/16.0;
+      interface_constraints(9,14) = 9.0/16.0;
+      interface_constraints(9,15) = 9.0/16.0;
+      interface_constraints(10,0) = -1.0/256.0;
+      interface_constraints(10,1) = -1.0/256.0;
+      interface_constraints(10,2) = -5.0/256.0;
+      interface_constraints(10,3) = -5.0/256.0;
+      interface_constraints(10,4) = 9.0/256.0;
+      interface_constraints(10,5) = 9.0/256.0;
+      interface_constraints(10,6) = 5.0/256.0;
+      interface_constraints(10,7) = -15.0/256.0;
+      interface_constraints(10,8) = 45.0/256.0;
+      interface_constraints(10,9) = 45.0/256.0;
+      interface_constraints(10,10) = 5.0/256.0;
+      interface_constraints(10,11) = -15.0/256.0;
+      interface_constraints(10,12) = -45.0/256.0;
+      interface_constraints(10,13) = -45.0/256.0;
+      interface_constraints(10,14) = 135.0/256.0;
+      interface_constraints(10,15) = 135.0/256.0;
+      interface_constraints(11,0) = -5.0/256.0;
+      interface_constraints(11,1) = -1.0/256.0;
+      interface_constraints(11,2) = -1.0/256.0;
+      interface_constraints(11,3) = -5.0/256.0;
+      interface_constraints(11,4) = -15.0/256.0;
+      interface_constraints(11,5) = 5.0/256.0;
+      interface_constraints(11,6) = 9.0/256.0;
+      interface_constraints(11,7) = 9.0/256.0;
+      interface_constraints(11,8) = -15.0/256.0;
+      interface_constraints(11,9) = 5.0/256.0;
+      interface_constraints(11,10) = 45.0/256.0;
+      interface_constraints(11,11) = 45.0/256.0;
+      interface_constraints(11,12) = 135.0/256.0;
+      interface_constraints(11,13) = -45.0/256.0;
+      interface_constraints(11,14) = 135.0/256.0;
+      interface_constraints(11,15) = -45.0/256.0;
+      interface_constraints(12,4) = -1.0/16.0;
+      interface_constraints(12,8) = -1.0/16.0;
+      interface_constraints(12,12) = 9.0/16.0;
+      interface_constraints(12,14) = 9.0/16.0;
+      interface_constraints(13,0) = 5.0/16.0;
+      interface_constraints(13,1) = 1.0/16.0;
+      interface_constraints(13,4) = 15.0/16.0;
+      interface_constraints(13,5) = -5.0/16.0;
+      interface_constraints(14,4) = 1.0;
+      interface_constraints(15,5) = 1.0;
+      interface_constraints(16,0) = 1.0/16.0;
+      interface_constraints(16,1) = 5.0/16.0;
+      interface_constraints(16,4) = -5.0/16.0;
+      interface_constraints(16,5) = 15.0/16.0;
+      interface_constraints(17,1) = 5.0/16.0;
+      interface_constraints(17,2) = 1.0/16.0;
+      interface_constraints(17,6) = 15.0/16.0;
+      interface_constraints(17,7) = -5.0/16.0;
+      interface_constraints(18,6) = 1.0;
+      interface_constraints(19,7) = 1.0;
+      interface_constraints(20,1) = 1.0/16.0;
+      interface_constraints(20,2) = 5.0/16.0;
+      interface_constraints(20,6) = -5.0/16.0;
+      interface_constraints(20,7) = 15.0/16.0;
+      interface_constraints(21,2) = 1.0/16.0;
+      interface_constraints(21,3) = 5.0/16.0;
+      interface_constraints(21,8) = 15.0/16.0;
+      interface_constraints(21,9) = -5.0/16.0;
+      interface_constraints(22,8) = 1.0;
+      interface_constraints(23,9) = 1.0;
+      interface_constraints(24,2) = 5.0/16.0;
+      interface_constraints(24,3) = 1.0/16.0;
+      interface_constraints(24,8) = -5.0/16.0;
+      interface_constraints(24,9) = 15.0/16.0;
+      interface_constraints(25,0) = 5.0/16.0;
+      interface_constraints(25,3) = 1.0/16.0;
+      interface_constraints(25,10) = 15.0/16.0;
+      interface_constraints(25,11) = -5.0/16.0;
+      interface_constraints(26,10) = 1.0;
+      interface_constraints(27,11) = 1.0;
+      interface_constraints(28,0) = 1.0/16.0;
+      interface_constraints(28,3) = 5.0/16.0;
+      interface_constraints(28,10) = -5.0/16.0;
+      interface_constraints(28,11) = 15.0/16.0;
+      interface_constraints(29,0) = 25.0/256.0;
+      interface_constraints(29,1) = 5.0/256.0;
+      interface_constraints(29,2) = 1.0/256.0;
+      interface_constraints(29,3) = 5.0/256.0;
+      interface_constraints(29,4) = 75.0/256.0;
+      interface_constraints(29,5) = -25.0/256.0;
+      interface_constraints(29,6) = 15.0/256.0;
+      interface_constraints(29,7) = -5.0/256.0;
+      interface_constraints(29,8) = 15.0/256.0;
+      interface_constraints(29,9) = -5.0/256.0;
+      interface_constraints(29,10) = 75.0/256.0;
+      interface_constraints(29,11) = -25.0/256.0;
+      interface_constraints(29,12) = 225.0/256.0;
+      interface_constraints(29,13) = -75.0/256.0;
+      interface_constraints(29,14) = -75.0/256.0;
+      interface_constraints(29,15) = 25.0/256.0;
+      interface_constraints(30,4) = 5.0/16.0;
+      interface_constraints(30,8) = 1.0/16.0;
+      interface_constraints(30,12) = 15.0/16.0;
+      interface_constraints(30,14) = -5.0/16.0;
+      interface_constraints(31,6) = 1.0/16.0;
+      interface_constraints(31,10) = 5.0/16.0;
+      interface_constraints(31,12) = 15.0/16.0;
+      interface_constraints(31,13) = -5.0/16.0;
+      interface_constraints(32,12) = 1.0;
+      interface_constraints(33,5) = 5.0/16.0;
+      interface_constraints(33,9) = 1.0/16.0;
+      interface_constraints(33,13) = 15.0/16.0;
+      interface_constraints(33,15) = -5.0/16.0;
+      interface_constraints(34,0) = 5.0/256.0;
+      interface_constraints(34,1) = 25.0/256.0;
+      interface_constraints(34,2) = 5.0/256.0;
+      interface_constraints(34,3) = 1.0/256.0;
+      interface_constraints(34,4) = -25.0/256.0;
+      interface_constraints(34,5) = 75.0/256.0;
+      interface_constraints(34,6) = 75.0/256.0;
+      interface_constraints(34,7) = -25.0/256.0;
+      interface_constraints(34,8) = -5.0/256.0;
+      interface_constraints(34,9) = 15.0/256.0;
+      interface_constraints(34,10) = 15.0/256.0;
+      interface_constraints(34,11) = -5.0/256.0;
+      interface_constraints(34,12) = -75.0/256.0;
+      interface_constraints(34,13) = 225.0/256.0;
+      interface_constraints(34,14) = 25.0/256.0;
+      interface_constraints(34,15) = -75.0/256.0;
+      interface_constraints(35,13) = 1.0;
+      interface_constraints(36,6) = 5.0/16.0;
+      interface_constraints(36,10) = 1.0/16.0;
+      interface_constraints(36,12) = -5.0/16.0;
+      interface_constraints(36,13) = 15.0/16.0;
+      interface_constraints(37,15) = 1.0;
+      interface_constraints(38,7) = 5.0/16.0;
+      interface_constraints(38,11) = 1.0/16.0;
+      interface_constraints(38,14) = -5.0/16.0;
+      interface_constraints(38,15) = 15.0/16.0;
+      interface_constraints(39,5) = 1.0/16.0;
+      interface_constraints(39,9) = 5.0/16.0;
+      interface_constraints(39,13) = -5.0/16.0;
+      interface_constraints(39,15) = 15.0/16.0;
+      interface_constraints(40,0) = 1.0/256.0;
+      interface_constraints(40,1) = 5.0/256.0;
+      interface_constraints(40,2) = 25.0/256.0;
+      interface_constraints(40,3) = 5.0/256.0;
+      interface_constraints(40,4) = -5.0/256.0;
+      interface_constraints(40,5) = 15.0/256.0;
+      interface_constraints(40,6) = -25.0/256.0;
+      interface_constraints(40,7) = 75.0/256.0;
+      interface_constraints(40,8) = -25.0/256.0;
+      interface_constraints(40,9) = 75.0/256.0;
+      interface_constraints(40,10) = -5.0/256.0;
+      interface_constraints(40,11) = 15.0/256.0;
+      interface_constraints(40,12) = 25.0/256.0;
+      interface_constraints(40,13) = -75.0/256.0;
+      interface_constraints(40,14) = -75.0/256.0;
+      interface_constraints(40,15) = 225.0/256.0;
+      interface_constraints(41,7) = 1.0/16.0;
+      interface_constraints(41,11) = 5.0/16.0;
+      interface_constraints(41,14) = 15.0/16.0;
+      interface_constraints(41,15) = -5.0/16.0;
+      interface_constraints(42,14) = 1.0;
+      interface_constraints(43,0) = 5.0/256.0;
+      interface_constraints(43,1) = 1.0/256.0;
+      interface_constraints(43,2) = 5.0/256.0;
+      interface_constraints(43,3) = 25.0/256.0;
+      interface_constraints(43,4) = 15.0/256.0;
+      interface_constraints(43,5) = -5.0/256.0;
+      interface_constraints(43,6) = -5.0/256.0;
+      interface_constraints(43,7) = 15.0/256.0;
+      interface_constraints(43,8) = 75.0/256.0;
+      interface_constraints(43,9) = -25.0/256.0;
+      interface_constraints(43,10) = -25.0/256.0;
+      interface_constraints(43,11) = 75.0/256.0;
+      interface_constraints(43,12) = -75.0/256.0;
+      interface_constraints(43,13) = 25.0/256.0;
+      interface_constraints(43,14) = 225.0/256.0;
+      interface_constraints(43,15) = -75.0/256.0;
+      interface_constraints(44,4) = 1.0/16.0;
+      interface_constraints(44,8) = 5.0/16.0;
+      interface_constraints(44,12) = -5.0/16.0;
+      interface_constraints(44,14) = 15.0/16.0;
+
+  initialize_matrices ();
+};
+
+
+
+template <>
+FECubicSub<3>::FECubicSub (const int) :
+               FELinearMapping<3> (0, 0, 0, 64)
+{
+  initialize_matrices ();
+};
+
+
+
+template <>
+void FECubicSub<3>::initialize_matrices () {
+      prolongation[0](0,0) = 1.0;
+      prolongation[0](1,0) = -1.0/16.0;
+      prolongation[0](1,1) = -1.0/16.0;
+      prolongation[0](1,8) = 9.0/16.0;
+      prolongation[0](1,9) = 9.0/16.0;
+      prolongation[0](2,0) = 1.0/256.0;
+      prolongation[0](2,1) = 1.0/256.0;
+      prolongation[0](2,2) = 1.0/256.0;
+      prolongation[0](2,3) = 1.0/256.0;
+      prolongation[0](2,8) = -9.0/256.0;
+      prolongation[0](2,9) = -9.0/256.0;
+      prolongation[0](2,10) = -9.0/256.0;
+      prolongation[0](2,11) = -9.0/256.0;
+      prolongation[0](2,12) = -9.0/256.0;
+      prolongation[0](2,13) = -9.0/256.0;
+      prolongation[0](2,14) = -9.0/256.0;
+      prolongation[0](2,15) = -9.0/256.0;
+      prolongation[0](2,32) = 81.0/256.0;
+      prolongation[0](2,33) = 81.0/256.0;
+      prolongation[0](2,34) = 81.0/256.0;
+      prolongation[0](2,35) = 81.0/256.0;
+      prolongation[0](3,0) = -1.0/16.0;
+      prolongation[0](3,3) = -1.0/16.0;
+      prolongation[0](3,14) = 9.0/16.0;
+      prolongation[0](3,15) = 9.0/16.0;
+      prolongation[0](4,0) = -1.0/16.0;
+      prolongation[0](4,4) = -1.0/16.0;
+      prolongation[0](4,24) = 9.0/16.0;
+      prolongation[0](4,25) = 9.0/16.0;
+      prolongation[0](5,0) = 1.0/256.0;
+      prolongation[0](5,1) = 1.0/256.0;
+      prolongation[0](5,4) = 1.0/256.0;
+      prolongation[0](5,5) = 1.0/256.0;
+      prolongation[0](5,8) = -9.0/256.0;
+      prolongation[0](5,9) = -9.0/256.0;
+      prolongation[0](5,16) = -9.0/256.0;
+      prolongation[0](5,17) = -9.0/256.0;
+      prolongation[0](5,24) = -9.0/256.0;
+      prolongation[0](5,25) = -9.0/256.0;
+      prolongation[0](5,26) = -9.0/256.0;
+      prolongation[0](5,27) = -9.0/256.0;
+      prolongation[0](5,40) = 81.0/256.0;
+      prolongation[0](5,41) = 81.0/256.0;
+      prolongation[0](5,42) = 81.0/256.0;
+      prolongation[0](5,43) = 81.0/256.0;
+      prolongation[0](6,0) = -1.0/4096.0;
+      prolongation[0](6,1) = -1.0/4096.0;
+      prolongation[0](6,2) = -1.0/4096.0;
+      prolongation[0](6,3) = -1.0/4096.0;
+      prolongation[0](6,4) = -1.0/4096.0;
+      prolongation[0](6,5) = -1.0/4096.0;
+      prolongation[0](6,6) = -1.0/4096.0;
+      prolongation[0](6,7) = -1.0/4096.0;
+      prolongation[0](6,8) = 9.0/4096.0;
+      prolongation[0](6,9) = 9.0/4096.0;
+      prolongation[0](6,10) = 9.0/4096.0;
+      prolongation[0](6,11) = 9.0/4096.0;
+      prolongation[0](6,12) = 9.0/4096.0;
+      prolongation[0](6,13) = 9.0/4096.0;
+      prolongation[0](6,14) = 9.0/4096.0;
+      prolongation[0](6,15) = 9.0/4096.0;
+      prolongation[0](6,16) = 9.0/4096.0;
+      prolongation[0](6,17) = 9.0/4096.0;
+      prolongation[0](6,18) = 9.0/4096.0;
+      prolongation[0](6,19) = 9.0/4096.0;
+      prolongation[0](6,20) = 9.0/4096.0;
+      prolongation[0](6,21) = 9.0/4096.0;
+      prolongation[0](6,22) = 9.0/4096.0;
+      prolongation[0](6,23) = 9.0/4096.0;
+      prolongation[0](6,24) = 9.0/4096.0;
+      prolongation[0](6,25) = 9.0/4096.0;
+      prolongation[0](6,26) = 9.0/4096.0;
+      prolongation[0](6,27) = 9.0/4096.0;
+      prolongation[0](6,28) = 9.0/4096.0;
+      prolongation[0](6,29) = 9.0/4096.0;
+      prolongation[0](6,30) = 9.0/4096.0;
+      prolongation[0](6,31) = 9.0/4096.0;
+      prolongation[0](6,32) = -81.0/4096.0;
+      prolongation[0](6,33) = -81.0/4096.0;
+      prolongation[0](6,34) = -81.0/4096.0;
+      prolongation[0](6,35) = -81.0/4096.0;
+      prolongation[0](6,36) = -81.0/4096.0;
+      prolongation[0](6,37) = -81.0/4096.0;
+      prolongation[0](6,38) = -81.0/4096.0;
+      prolongation[0](6,39) = -81.0/4096.0;
+      prolongation[0](6,40) = -81.0/4096.0;
+      prolongation[0](6,41) = -81.0/4096.0;
+      prolongation[0](6,42) = -81.0/4096.0;
+      prolongation[0](6,43) = -81.0/4096.0;
+      prolongation[0](6,44) = -81.0/4096.0;
+      prolongation[0](6,45) = -81.0/4096.0;
+      prolongation[0](6,46) = -81.0/4096.0;
+      prolongation[0](6,47) = -81.0/4096.0;
+      prolongation[0](6,48) = -81.0/4096.0;
+      prolongation[0](6,49) = -81.0/4096.0;
+      prolongation[0](6,50) = -81.0/4096.0;
+      prolongation[0](6,51) = -81.0/4096.0;
+      prolongation[0](6,52) = -81.0/4096.0;
+      prolongation[0](6,53) = -81.0/4096.0;
+      prolongation[0](6,54) = -81.0/4096.0;
+      prolongation[0](6,55) = -81.0/4096.0;
+      prolongation[0](6,56) = 729.0/4096.0;
+      prolongation[0](6,57) = 729.0/4096.0;
+      prolongation[0](6,58) = 729.0/4096.0;
+      prolongation[0](6,59) = 729.0/4096.0;
+      prolongation[0](6,60) = 729.0/4096.0;
+      prolongation[0](6,61) = 729.0/4096.0;
+      prolongation[0](6,62) = 729.0/4096.0;
+      prolongation[0](6,63) = 729.0/4096.0;
+      prolongation[0](7,0) = 1.0/256.0;
+      prolongation[0](7,3) = 1.0/256.0;
+      prolongation[0](7,4) = 1.0/256.0;
+      prolongation[0](7,7) = 1.0/256.0;
+      prolongation[0](7,14) = -9.0/256.0;
+      prolongation[0](7,15) = -9.0/256.0;
+      prolongation[0](7,22) = -9.0/256.0;
+      prolongation[0](7,23) = -9.0/256.0;
+      prolongation[0](7,24) = -9.0/256.0;
+      prolongation[0](7,25) = -9.0/256.0;
+      prolongation[0](7,30) = -9.0/256.0;
+      prolongation[0](7,31) = -9.0/256.0;
+      prolongation[0](7,52) = 81.0/256.0;
+      prolongation[0](7,53) = 81.0/256.0;
+      prolongation[0](7,54) = 81.0/256.0;
+      prolongation[0](7,55) = 81.0/256.0;
+      prolongation[0](8,0) = 5.0/16.0;
+      prolongation[0](8,1) = 1.0/16.0;
+      prolongation[0](8,8) = 15.0/16.0;
+      prolongation[0](8,9) = -5.0/16.0;
+      prolongation[0](9,8) = 1.0;
+      prolongation[0](10,0) = -5.0/256.0;
+      prolongation[0](10,1) = -5.0/256.0;
+      prolongation[0](10,2) = -1.0/256.0;
+      prolongation[0](10,3) = -1.0/256.0;
+      prolongation[0](10,8) = 45.0/256.0;
+      prolongation[0](10,9) = 45.0/256.0;
+      prolongation[0](10,10) = -15.0/256.0;
+      prolongation[0](10,11) = 5.0/256.0;
+      prolongation[0](10,12) = 9.0/256.0;
+      prolongation[0](10,13) = 9.0/256.0;
+      prolongation[0](10,14) = -15.0/256.0;
+      prolongation[0](10,15) = 5.0/256.0;
+      prolongation[0](10,32) = 135.0/256.0;
+      prolongation[0](10,33) = 135.0/256.0;
+      prolongation[0](10,34) = -45.0/256.0;
+      prolongation[0](10,35) = -45.0/256.0;
+      prolongation[0](11,10) = -1.0/16.0;
+      prolongation[0](11,14) = -1.0/16.0;
+      prolongation[0](11,32) = 9.0/16.0;
+      prolongation[0](11,33) = 9.0/16.0;
+      prolongation[0](12,0) = -5.0/256.0;
+      prolongation[0](12,1) = -1.0/256.0;
+      prolongation[0](12,2) = -1.0/256.0;
+      prolongation[0](12,3) = -5.0/256.0;
+      prolongation[0](12,8) = -15.0/256.0;
+      prolongation[0](12,9) = 5.0/256.0;
+      prolongation[0](12,10) = 9.0/256.0;
+      prolongation[0](12,11) = 9.0/256.0;
+      prolongation[0](12,12) = -15.0/256.0;
+      prolongation[0](12,13) = 5.0/256.0;
+      prolongation[0](12,14) = 45.0/256.0;
+      prolongation[0](12,15) = 45.0/256.0;
+      prolongation[0](12,32) = 135.0/256.0;
+      prolongation[0](12,33) = -45.0/256.0;
+      prolongation[0](12,34) = 135.0/256.0;
+      prolongation[0](12,35) = -45.0/256.0;
+      prolongation[0](13,8) = -1.0/16.0;
+      prolongation[0](13,12) = -1.0/16.0;
+      prolongation[0](13,32) = 9.0/16.0;
+      prolongation[0](13,34) = 9.0/16.0;
+      prolongation[0](14,0) = 5.0/16.0;
+      prolongation[0](14,3) = 1.0/16.0;
+      prolongation[0](14,14) = 15.0/16.0;
+      prolongation[0](14,15) = -5.0/16.0;
+      prolongation[0](15,14) = 1.0;
+      prolongation[0](16,0) = -5.0/256.0;
+      prolongation[0](16,1) = -1.0/256.0;
+      prolongation[0](16,4) = -5.0/256.0;
+      prolongation[0](16,5) = -1.0/256.0;
+      prolongation[0](16,8) = -15.0/256.0;
+      prolongation[0](16,9) = 5.0/256.0;
+      prolongation[0](16,16) = -15.0/256.0;
+      prolongation[0](16,17) = 5.0/256.0;
+      prolongation[0](16,24) = 45.0/256.0;
+      prolongation[0](16,25) = 45.0/256.0;
+      prolongation[0](16,26) = 9.0/256.0;
+      prolongation[0](16,27) = 9.0/256.0;
+      prolongation[0](16,40) = 135.0/256.0;
+      prolongation[0](16,41) = -45.0/256.0;
+      prolongation[0](16,42) = 135.0/256.0;
+      prolongation[0](16,43) = -45.0/256.0;
+      prolongation[0](17,8) = -1.0/16.0;
+      prolongation[0](17,16) = -1.0/16.0;
+      prolongation[0](17,40) = 9.0/16.0;
+      prolongation[0](17,42) = 9.0/16.0;
+      prolongation[0](18,0) = 5.0/4096.0;
+      prolongation[0](18,1) = 5.0/4096.0;
+      prolongation[0](18,2) = 1.0/4096.0;
+      prolongation[0](18,3) = 1.0/4096.0;
+      prolongation[0](18,4) = 5.0/4096.0;
+      prolongation[0](18,5) = 5.0/4096.0;
+      prolongation[0](18,6) = 1.0/4096.0;
+      prolongation[0](18,7) = 1.0/4096.0;
+      prolongation[0](18,8) = -45.0/4096.0;
+      prolongation[0](18,9) = -45.0/4096.0;
+      prolongation[0](18,10) = 15.0/4096.0;
+      prolongation[0](18,11) = -5.0/4096.0;
+      prolongation[0](18,12) = -9.0/4096.0;
+      prolongation[0](18,13) = -9.0/4096.0;
+      prolongation[0](18,14) = 15.0/4096.0;
+      prolongation[0](18,15) = -5.0/4096.0;
+      prolongation[0](18,16) = -45.0/4096.0;
+      prolongation[0](18,17) = -45.0/4096.0;
+      prolongation[0](18,18) = 15.0/4096.0;
+      prolongation[0](18,19) = -5.0/4096.0;
+      prolongation[0](18,20) = -9.0/4096.0;
+      prolongation[0](18,21) = -9.0/4096.0;
+      prolongation[0](18,22) = 15.0/4096.0;
+      prolongation[0](18,23) = -5.0/4096.0;
+      prolongation[0](18,24) = -45.0/4096.0;
+      prolongation[0](18,25) = -45.0/4096.0;
+      prolongation[0](18,26) = -45.0/4096.0;
+      prolongation[0](18,27) = -45.0/4096.0;
+      prolongation[0](18,28) = -9.0/4096.0;
+      prolongation[0](18,29) = -9.0/4096.0;
+      prolongation[0](18,30) = -9.0/4096.0;
+      prolongation[0](18,31) = -9.0/4096.0;
+      prolongation[0](18,32) = -135.0/4096.0;
+      prolongation[0](18,33) = -135.0/4096.0;
+      prolongation[0](18,34) = 45.0/4096.0;
+      prolongation[0](18,35) = 45.0/4096.0;
+      prolongation[0](18,36) = -135.0/4096.0;
+      prolongation[0](18,37) = -135.0/4096.0;
+      prolongation[0](18,38) = 45.0/4096.0;
+      prolongation[0](18,39) = 45.0/4096.0;
+      prolongation[0](18,40) = 405.0/4096.0;
+      prolongation[0](18,41) = 405.0/4096.0;
+      prolongation[0](18,42) = 405.0/4096.0;
+      prolongation[0](18,43) = 405.0/4096.0;
+      prolongation[0](18,44) = -135.0/4096.0;
+      prolongation[0](18,45) = -135.0/4096.0;
+      prolongation[0](18,46) = 45.0/4096.0;
+      prolongation[0](18,47) = 45.0/4096.0;
+      prolongation[0](18,48) = 81.0/4096.0;
+      prolongation[0](18,49) = 81.0/4096.0;
+      prolongation[0](18,50) = 81.0/4096.0;
+      prolongation[0](18,51) = 81.0/4096.0;
+      prolongation[0](18,52) = -135.0/4096.0;
+      prolongation[0](18,53) = -135.0/4096.0;
+      prolongation[0](18,54) = 45.0/4096.0;
+      prolongation[0](18,55) = 45.0/4096.0;
+      prolongation[0](18,56) = 1215.0/4096.0;
+      prolongation[0](18,57) = 1215.0/4096.0;
+      prolongation[0](18,58) = 1215.0/4096.0;
+      prolongation[0](18,59) = 1215.0/4096.0;
+      prolongation[0](18,60) = -405.0/4096.0;
+      prolongation[0](18,61) = -405.0/4096.0;
+      prolongation[0](18,62) = -405.0/4096.0;
+      prolongation[0](18,63) = -405.0/4096.0;
+      prolongation[0](19,10) = 1.0/256.0;
+      prolongation[0](19,14) = 1.0/256.0;
+      prolongation[0](19,18) = 1.0/256.0;
+      prolongation[0](19,22) = 1.0/256.0;
+      prolongation[0](19,32) = -9.0/256.0;
+      prolongation[0](19,33) = -9.0/256.0;
+      prolongation[0](19,36) = -9.0/256.0;
+      prolongation[0](19,37) = -9.0/256.0;
+      prolongation[0](19,44) = -9.0/256.0;
+      prolongation[0](19,45) = -9.0/256.0;
+      prolongation[0](19,52) = -9.0/256.0;
+      prolongation[0](19,53) = -9.0/256.0;
+      prolongation[0](19,56) = 81.0/256.0;
+      prolongation[0](19,57) = 81.0/256.0;
+      prolongation[0](19,58) = 81.0/256.0;
+      prolongation[0](19,59) = 81.0/256.0;
+      prolongation[0](20,0) = 5.0/4096.0;
+      prolongation[0](20,1) = 1.0/4096.0;
+      prolongation[0](20,2) = 1.0/4096.0;
+      prolongation[0](20,3) = 5.0/4096.0;
+      prolongation[0](20,4) = 5.0/4096.0;
+      prolongation[0](20,5) = 1.0/4096.0;
+      prolongation[0](20,6) = 1.0/4096.0;
+      prolongation[0](20,7) = 5.0/4096.0;
+      prolongation[0](20,8) = 15.0/4096.0;
+      prolongation[0](20,9) = -5.0/4096.0;
+      prolongation[0](20,10) = -9.0/4096.0;
+      prolongation[0](20,11) = -9.0/4096.0;
+      prolongation[0](20,12) = 15.0/4096.0;
+      prolongation[0](20,13) = -5.0/4096.0;
+      prolongation[0](20,14) = -45.0/4096.0;
+      prolongation[0](20,15) = -45.0/4096.0;
+      prolongation[0](20,16) = 15.0/4096.0;
+      prolongation[0](20,17) = -5.0/4096.0;
+      prolongation[0](20,18) = -9.0/4096.0;
+      prolongation[0](20,19) = -9.0/4096.0;
+      prolongation[0](20,20) = 15.0/4096.0;
+      prolongation[0](20,21) = -5.0/4096.0;
+      prolongation[0](20,22) = -45.0/4096.0;
+      prolongation[0](20,23) = -45.0/4096.0;
+      prolongation[0](20,24) = -45.0/4096.0;
+      prolongation[0](20,25) = -45.0/4096.0;
+      prolongation[0](20,26) = -9.0/4096.0;
+      prolongation[0](20,27) = -9.0/4096.0;
+      prolongation[0](20,28) = -9.0/4096.0;
+      prolongation[0](20,29) = -9.0/4096.0;
+      prolongation[0](20,30) = -45.0/4096.0;
+      prolongation[0](20,31) = -45.0/4096.0;
+      prolongation[0](20,32) = -135.0/4096.0;
+      prolongation[0](20,33) = 45.0/4096.0;
+      prolongation[0](20,34) = -135.0/4096.0;
+      prolongation[0](20,35) = 45.0/4096.0;
+      prolongation[0](20,36) = -135.0/4096.0;
+      prolongation[0](20,37) = 45.0/4096.0;
+      prolongation[0](20,38) = -135.0/4096.0;
+      prolongation[0](20,39) = 45.0/4096.0;
+      prolongation[0](20,40) = -135.0/4096.0;
+      prolongation[0](20,41) = 45.0/4096.0;
+      prolongation[0](20,42) = -135.0/4096.0;
+      prolongation[0](20,43) = 45.0/4096.0;
+      prolongation[0](20,44) = 81.0/4096.0;
+      prolongation[0](20,45) = 81.0/4096.0;
+      prolongation[0](20,46) = 81.0/4096.0;
+      prolongation[0](20,47) = 81.0/4096.0;
+      prolongation[0](20,48) = -135.0/4096.0;
+      prolongation[0](20,49) = 45.0/4096.0;
+      prolongation[0](20,50) = -135.0/4096.0;
+      prolongation[0](20,51) = 45.0/4096.0;
+      prolongation[0](20,52) = 405.0/4096.0;
+      prolongation[0](20,53) = 405.0/4096.0;
+      prolongation[0](20,54) = 405.0/4096.0;
+      prolongation[0](20,55) = 405.0/4096.0;
+      prolongation[0](20,56) = 1215.0/4096.0;
+      prolongation[0](20,57) = -405.0/4096.0;
+      prolongation[0](20,58) = 1215.0/4096.0;
+      prolongation[0](20,59) = -405.0/4096.0;
+      prolongation[0](20,60) = 1215.0/4096.0;
+      prolongation[0](20,61) = -405.0/4096.0;
+      prolongation[0](20,62) = 1215.0/4096.0;
+      prolongation[0](20,63) = -405.0/4096.0;
+      prolongation[0](21,8) = 1.0/256.0;
+      prolongation[0](21,12) = 1.0/256.0;
+      prolongation[0](21,16) = 1.0/256.0;
+      prolongation[0](21,20) = 1.0/256.0;
+      prolongation[0](21,32) = -9.0/256.0;
+      prolongation[0](21,34) = -9.0/256.0;
+      prolongation[0](21,36) = -9.0/256.0;
+      prolongation[0](21,38) = -9.0/256.0;
+      prolongation[0](21,40) = -9.0/256.0;
+      prolongation[0](21,42) = -9.0/256.0;
+      prolongation[0](21,48) = -9.0/256.0;
+      prolongation[0](21,50) = -9.0/256.0;
+      prolongation[0](21,56) = 81.0/256.0;
+      prolongation[0](21,58) = 81.0/256.0;
+      prolongation[0](21,60) = 81.0/256.0;
+      prolongation[0](21,62) = 81.0/256.0;
+      prolongation[0](22,0) = -5.0/256.0;
+      prolongation[0](22,3) = -1.0/256.0;
+      prolongation[0](22,4) = -5.0/256.0;
+      prolongation[0](22,7) = -1.0/256.0;
+      prolongation[0](22,14) = -15.0/256.0;
+      prolongation[0](22,15) = 5.0/256.0;
+      prolongation[0](22,22) = -15.0/256.0;
+      prolongation[0](22,23) = 5.0/256.0;
+      prolongation[0](22,24) = 45.0/256.0;
+      prolongation[0](22,25) = 45.0/256.0;
+      prolongation[0](22,30) = 9.0/256.0;
+      prolongation[0](22,31) = 9.0/256.0;
+      prolongation[0](22,52) = 135.0/256.0;
+      prolongation[0](22,53) = 135.0/256.0;
+      prolongation[0](22,54) = -45.0/256.0;
+      prolongation[0](22,55) = -45.0/256.0;
+      prolongation[0](23,14) = -1.0/16.0;
+      prolongation[0](23,22) = -1.0/16.0;
+      prolongation[0](23,52) = 9.0/16.0;
+      prolongation[0](23,53) = 9.0/16.0;
+      prolongation[0](24,0) = 5.0/16.0;
+      prolongation[0](24,4) = 1.0/16.0;
+      prolongation[0](24,24) = 15.0/16.0;
+      prolongation[0](24,25) = -5.0/16.0;
+      prolongation[0](25,24) = 1.0;
+      prolongation[0](26,0) = -5.0/256.0;
+      prolongation[0](26,1) = -5.0/256.0;
+      prolongation[0](26,4) = -1.0/256.0;
+      prolongation[0](26,5) = -1.0/256.0;
+      prolongation[0](26,8) = 45.0/256.0;
+      prolongation[0](26,9) = 45.0/256.0;
+      prolongation[0](26,16) = 9.0/256.0;
+      prolongation[0](26,17) = 9.0/256.0;
+      prolongation[0](26,24) = -15.0/256.0;
+      prolongation[0](26,25) = 5.0/256.0;
+      prolongation[0](26,26) = -15.0/256.0;
+      prolongation[0](26,27) = 5.0/256.0;
+      prolongation[0](26,40) = 135.0/256.0;
+      prolongation[0](26,41) = 135.0/256.0;
+      prolongation[0](26,42) = -45.0/256.0;
+      prolongation[0](26,43) = -45.0/256.0;
+      prolongation[0](27,24) = -1.0/16.0;
+      prolongation[0](27,26) = -1.0/16.0;
+      prolongation[0](27,40) = 9.0/16.0;
+      prolongation[0](27,41) = 9.0/16.0;
+      prolongation[0](28,0) = 5.0/4096.0;
+      prolongation[0](28,1) = 5.0/4096.0;
+      prolongation[0](28,2) = 5.0/4096.0;
+      prolongation[0](28,3) = 5.0/4096.0;
+      prolongation[0](28,4) = 1.0/4096.0;
+      prolongation[0](28,5) = 1.0/4096.0;
+      prolongation[0](28,6) = 1.0/4096.0;
+      prolongation[0](28,7) = 1.0/4096.0;
+      prolongation[0](28,8) = -45.0/4096.0;
+      prolongation[0](28,9) = -45.0/4096.0;
+      prolongation[0](28,10) = -45.0/4096.0;
+      prolongation[0](28,11) = -45.0/4096.0;
+      prolongation[0](28,12) = -45.0/4096.0;
+      prolongation[0](28,13) = -45.0/4096.0;
+      prolongation[0](28,14) = -45.0/4096.0;
+      prolongation[0](28,15) = -45.0/4096.0;
+      prolongation[0](28,16) = -9.0/4096.0;
+      prolongation[0](28,17) = -9.0/4096.0;
+      prolongation[0](28,18) = -9.0/4096.0;
+      prolongation[0](28,19) = -9.0/4096.0;
+      prolongation[0](28,20) = -9.0/4096.0;
+      prolongation[0](28,21) = -9.0/4096.0;
+      prolongation[0](28,22) = -9.0/4096.0;
+      prolongation[0](28,23) = -9.0/4096.0;
+      prolongation[0](28,24) = 15.0/4096.0;
+      prolongation[0](28,25) = -5.0/4096.0;
+      prolongation[0](28,26) = 15.0/4096.0;
+      prolongation[0](28,27) = -5.0/4096.0;
+      prolongation[0](28,28) = 15.0/4096.0;
+      prolongation[0](28,29) = -5.0/4096.0;
+      prolongation[0](28,30) = 15.0/4096.0;
+      prolongation[0](28,31) = -5.0/4096.0;
+      prolongation[0](28,32) = 405.0/4096.0;
+      prolongation[0](28,33) = 405.0/4096.0;
+      prolongation[0](28,34) = 405.0/4096.0;
+      prolongation[0](28,35) = 405.0/4096.0;
+      prolongation[0](28,36) = 81.0/4096.0;
+      prolongation[0](28,37) = 81.0/4096.0;
+      prolongation[0](28,38) = 81.0/4096.0;
+      prolongation[0](28,39) = 81.0/4096.0;
+      prolongation[0](28,40) = -135.0/4096.0;
+      prolongation[0](28,41) = -135.0/4096.0;
+      prolongation[0](28,42) = 45.0/4096.0;
+      prolongation[0](28,43) = 45.0/4096.0;
+      prolongation[0](28,44) = -135.0/4096.0;
+      prolongation[0](28,45) = 45.0/4096.0;
+      prolongation[0](28,46) = -135.0/4096.0;
+      prolongation[0](28,47) = 45.0/4096.0;
+      prolongation[0](28,48) = -135.0/4096.0;
+      prolongation[0](28,49) = -135.0/4096.0;
+      prolongation[0](28,50) = 45.0/4096.0;
+      prolongation[0](28,51) = 45.0/4096.0;
+      prolongation[0](28,52) = -135.0/4096.0;
+      prolongation[0](28,53) = 45.0/4096.0;
+      prolongation[0](28,54) = -135.0/4096.0;
+      prolongation[0](28,55) = 45.0/4096.0;
+      prolongation[0](28,56) = 1215.0/4096.0;
+      prolongation[0](28,57) = 1215.0/4096.0;
+      prolongation[0](28,58) = -405.0/4096.0;
+      prolongation[0](28,59) = -405.0/4096.0;
+      prolongation[0](28,60) = 1215.0/4096.0;
+      prolongation[0](28,61) = 1215.0/4096.0;
+      prolongation[0](28,62) = -405.0/4096.0;
+      prolongation[0](28,63) = -405.0/4096.0;
+      prolongation[0](29,24) = 1.0/256.0;
+      prolongation[0](29,26) = 1.0/256.0;
+      prolongation[0](29,28) = 1.0/256.0;
+      prolongation[0](29,30) = 1.0/256.0;
+      prolongation[0](29,40) = -9.0/256.0;
+      prolongation[0](29,41) = -9.0/256.0;
+      prolongation[0](29,44) = -9.0/256.0;
+      prolongation[0](29,46) = -9.0/256.0;
+      prolongation[0](29,48) = -9.0/256.0;
+      prolongation[0](29,49) = -9.0/256.0;
+      prolongation[0](29,52) = -9.0/256.0;
+      prolongation[0](29,54) = -9.0/256.0;
+      prolongation[0](29,56) = 81.0/256.0;
+      prolongation[0](29,57) = 81.0/256.0;
+      prolongation[0](29,60) = 81.0/256.0;
+      prolongation[0](29,61) = 81.0/256.0;
+      prolongation[0](30,0) = -5.0/256.0;
+      prolongation[0](30,3) = -5.0/256.0;
+      prolongation[0](30,4) = -1.0/256.0;
+      prolongation[0](30,7) = -1.0/256.0;
+      prolongation[0](30,14) = 45.0/256.0;
+      prolongation[0](30,15) = 45.0/256.0;
+      prolongation[0](30,22) = 9.0/256.0;
+      prolongation[0](30,23) = 9.0/256.0;
+      prolongation[0](30,24) = -15.0/256.0;
+      prolongation[0](30,25) = 5.0/256.0;
+      prolongation[0](30,30) = -15.0/256.0;
+      prolongation[0](30,31) = 5.0/256.0;
+      prolongation[0](30,52) = 135.0/256.0;
+      prolongation[0](30,53) = -45.0/256.0;
+      prolongation[0](30,54) = 135.0/256.0;
+      prolongation[0](30,55) = -45.0/256.0;
+      prolongation[0](31,24) = -1.0/16.0;
+      prolongation[0](31,30) = -1.0/16.0;
+      prolongation[0](31,52) = 9.0/16.0;
+      prolongation[0](31,54) = 9.0/16.0;
+      prolongation[0](32,0) = 25.0/256.0;
+      prolongation[0](32,1) = 5.0/256.0;
+      prolongation[0](32,2) = 1.0/256.0;
+      prolongation[0](32,3) = 5.0/256.0;
+      prolongation[0](32,8) = 75.0/256.0;
+      prolongation[0](32,9) = -25.0/256.0;
+      prolongation[0](32,10) = 15.0/256.0;
+      prolongation[0](32,11) = -5.0/256.0;
+      prolongation[0](32,12) = 15.0/256.0;
+      prolongation[0](32,13) = -5.0/256.0;
+      prolongation[0](32,14) = 75.0/256.0;
+      prolongation[0](32,15) = -25.0/256.0;
+      prolongation[0](32,32) = 225.0/256.0;
+      prolongation[0](32,33) = -75.0/256.0;
+      prolongation[0](32,34) = -75.0/256.0;
+      prolongation[0](32,35) = 25.0/256.0;
+      prolongation[0](33,8) = 5.0/16.0;
+      prolongation[0](33,12) = 1.0/16.0;
+      prolongation[0](33,32) = 15.0/16.0;
+      prolongation[0](33,34) = -5.0/16.0;
+      prolongation[0](34,10) = 1.0/16.0;
+      prolongation[0](34,14) = 5.0/16.0;
+      prolongation[0](34,32) = 15.0/16.0;
+      prolongation[0](34,33) = -5.0/16.0;
+      prolongation[0](35,32) = 1.0;
+      prolongation[0](36,0) = -25.0/4096.0;
+      prolongation[0](36,1) = -5.0/4096.0;
+      prolongation[0](36,2) = -1.0/4096.0;
+      prolongation[0](36,3) = -5.0/4096.0;
+      prolongation[0](36,4) = -25.0/4096.0;
+      prolongation[0](36,5) = -5.0/4096.0;
+      prolongation[0](36,6) = -1.0/4096.0;
+      prolongation[0](36,7) = -5.0/4096.0;
+      prolongation[0](36,8) = -75.0/4096.0;
+      prolongation[0](36,9) = 25.0/4096.0;
+      prolongation[0](36,10) = -15.0/4096.0;
+      prolongation[0](36,11) = 5.0/4096.0;
+      prolongation[0](36,12) = -15.0/4096.0;
+      prolongation[0](36,13) = 5.0/4096.0;
+      prolongation[0](36,14) = -75.0/4096.0;
+      prolongation[0](36,15) = 25.0/4096.0;
+      prolongation[0](36,16) = -75.0/4096.0;
+      prolongation[0](36,17) = 25.0/4096.0;
+      prolongation[0](36,18) = -15.0/4096.0;
+      prolongation[0](36,19) = 5.0/4096.0;
+      prolongation[0](36,20) = -15.0/4096.0;
+      prolongation[0](36,21) = 5.0/4096.0;
+      prolongation[0](36,22) = -75.0/4096.0;
+      prolongation[0](36,23) = 25.0/4096.0;
+      prolongation[0](36,24) = 225.0/4096.0;
+      prolongation[0](36,25) = 225.0/4096.0;
+      prolongation[0](36,26) = 45.0/4096.0;
+      prolongation[0](36,27) = 45.0/4096.0;
+      prolongation[0](36,28) = 9.0/4096.0;
+      prolongation[0](36,29) = 9.0/4096.0;
+      prolongation[0](36,30) = 45.0/4096.0;
+      prolongation[0](36,31) = 45.0/4096.0;
+      prolongation[0](36,32) = -225.0/4096.0;
+      prolongation[0](36,33) = 75.0/4096.0;
+      prolongation[0](36,34) = 75.0/4096.0;
+      prolongation[0](36,35) = -25.0/4096.0;
+      prolongation[0](36,36) = -225.0/4096.0;
+      prolongation[0](36,37) = 75.0/4096.0;
+      prolongation[0](36,38) = 75.0/4096.0;
+      prolongation[0](36,39) = -25.0/4096.0;
+      prolongation[0](36,40) = 675.0/4096.0;
+      prolongation[0](36,41) = -225.0/4096.0;
+      prolongation[0](36,42) = 675.0/4096.0;
+      prolongation[0](36,43) = -225.0/4096.0;
+      prolongation[0](36,44) = 135.0/4096.0;
+      prolongation[0](36,45) = 135.0/4096.0;
+      prolongation[0](36,46) = -45.0/4096.0;
+      prolongation[0](36,47) = -45.0/4096.0;
+      prolongation[0](36,48) = 135.0/4096.0;
+      prolongation[0](36,49) = -45.0/4096.0;
+      prolongation[0](36,50) = 135.0/4096.0;
+      prolongation[0](36,51) = -45.0/4096.0;
+      prolongation[0](36,52) = 675.0/4096.0;
+      prolongation[0](36,53) = 675.0/4096.0;
+      prolongation[0](36,54) = -225.0/4096.0;
+      prolongation[0](36,55) = -225.0/4096.0;
+      prolongation[0](36,56) = 2025.0/4096.0;
+      prolongation[0](36,57) = -675.0/4096.0;
+      prolongation[0](36,58) = 2025.0/4096.0;
+      prolongation[0](36,59) = -675.0/4096.0;
+      prolongation[0](36,60) = -675.0/4096.0;
+      prolongation[0](36,61) = 225.0/4096.0;
+      prolongation[0](36,62) = -675.0/4096.0;
+      prolongation[0](36,63) = 225.0/4096.0;
+      prolongation[0](37,8) = -5.0/256.0;
+      prolongation[0](37,12) = -1.0/256.0;
+      prolongation[0](37,16) = -5.0/256.0;
+      prolongation[0](37,20) = -1.0/256.0;
+      prolongation[0](37,32) = -15.0/256.0;
+      prolongation[0](37,34) = 5.0/256.0;
+      prolongation[0](37,36) = -15.0/256.0;
+      prolongation[0](37,38) = 5.0/256.0;
+      prolongation[0](37,40) = 45.0/256.0;
+      prolongation[0](37,42) = 45.0/256.0;
+      prolongation[0](37,48) = 9.0/256.0;
+      prolongation[0](37,50) = 9.0/256.0;
+      prolongation[0](37,56) = 135.0/256.0;
+      prolongation[0](37,58) = 135.0/256.0;
+      prolongation[0](37,60) = -45.0/256.0;
+      prolongation[0](37,62) = -45.0/256.0;
+      prolongation[0](38,10) = -1.0/256.0;
+      prolongation[0](38,14) = -5.0/256.0;
+      prolongation[0](38,18) = -1.0/256.0;
+      prolongation[0](38,22) = -5.0/256.0;
+      prolongation[0](38,32) = -15.0/256.0;
+      prolongation[0](38,33) = 5.0/256.0;
+      prolongation[0](38,36) = -15.0/256.0;
+      prolongation[0](38,37) = 5.0/256.0;
+      prolongation[0](38,44) = 9.0/256.0;
+      prolongation[0](38,45) = 9.0/256.0;
+      prolongation[0](38,52) = 45.0/256.0;
+      prolongation[0](38,53) = 45.0/256.0;
+      prolongation[0](38,56) = 135.0/256.0;
+      prolongation[0](38,57) = -45.0/256.0;
+      prolongation[0](38,58) = 135.0/256.0;
+      prolongation[0](38,59) = -45.0/256.0;
+      prolongation[0](39,32) = -1.0/16.0;
+      prolongation[0](39,36) = -1.0/16.0;
+      prolongation[0](39,56) = 9.0/16.0;
+      prolongation[0](39,58) = 9.0/16.0;
+      prolongation[0](40,0) = 25.0/256.0;
+      prolongation[0](40,1) = 5.0/256.0;
+      prolongation[0](40,4) = 5.0/256.0;
+      prolongation[0](40,5) = 1.0/256.0;
+      prolongation[0](40,8) = 75.0/256.0;
+      prolongation[0](40,9) = -25.0/256.0;
+      prolongation[0](40,16) = 15.0/256.0;
+      prolongation[0](40,17) = -5.0/256.0;
+      prolongation[0](40,24) = 75.0/256.0;
+      prolongation[0](40,25) = -25.0/256.0;
+      prolongation[0](40,26) = 15.0/256.0;
+      prolongation[0](40,27) = -5.0/256.0;
+      prolongation[0](40,40) = 225.0/256.0;
+      prolongation[0](40,41) = -75.0/256.0;
+      prolongation[0](40,42) = -75.0/256.0;
+      prolongation[0](40,43) = 25.0/256.0;
+      prolongation[0](41,8) = 5.0/16.0;
+      prolongation[0](41,16) = 1.0/16.0;
+      prolongation[0](41,40) = 15.0/16.0;
+      prolongation[0](41,42) = -5.0/16.0;
+      prolongation[0](42,24) = 5.0/16.0;
+      prolongation[0](42,26) = 1.0/16.0;
+      prolongation[0](42,40) = 15.0/16.0;
+      prolongation[0](42,41) = -5.0/16.0;
+      prolongation[0](43,40) = 1.0;
+      prolongation[0](44,0) = -25.0/4096.0;
+      prolongation[0](44,1) = -25.0/4096.0;
+      prolongation[0](44,2) = -5.0/4096.0;
+      prolongation[0](44,3) = -5.0/4096.0;
+      prolongation[0](44,4) = -5.0/4096.0;
+      prolongation[0](44,5) = -5.0/4096.0;
+      prolongation[0](44,6) = -1.0/4096.0;
+      prolongation[0](44,7) = -1.0/4096.0;
+      prolongation[0](44,8) = 225.0/4096.0;
+      prolongation[0](44,9) = 225.0/4096.0;
+      prolongation[0](44,10) = -75.0/4096.0;
+      prolongation[0](44,11) = 25.0/4096.0;
+      prolongation[0](44,12) = 45.0/4096.0;
+      prolongation[0](44,13) = 45.0/4096.0;
+      prolongation[0](44,14) = -75.0/4096.0;
+      prolongation[0](44,15) = 25.0/4096.0;
+      prolongation[0](44,16) = 45.0/4096.0;
+      prolongation[0](44,17) = 45.0/4096.0;
+      prolongation[0](44,18) = -15.0/4096.0;
+      prolongation[0](44,19) = 5.0/4096.0;
+      prolongation[0](44,20) = 9.0/4096.0;
+      prolongation[0](44,21) = 9.0/4096.0;
+      prolongation[0](44,22) = -15.0/4096.0;
+      prolongation[0](44,23) = 5.0/4096.0;
+      prolongation[0](44,24) = -75.0/4096.0;
+      prolongation[0](44,25) = 25.0/4096.0;
+      prolongation[0](44,26) = -75.0/4096.0;
+      prolongation[0](44,27) = 25.0/4096.0;
+      prolongation[0](44,28) = -15.0/4096.0;
+      prolongation[0](44,29) = 5.0/4096.0;
+      prolongation[0](44,30) = -15.0/4096.0;
+      prolongation[0](44,31) = 5.0/4096.0;
+      prolongation[0](44,32) = 675.0/4096.0;
+      prolongation[0](44,33) = 675.0/4096.0;
+      prolongation[0](44,34) = -225.0/4096.0;
+      prolongation[0](44,35) = -225.0/4096.0;
+      prolongation[0](44,36) = 135.0/4096.0;
+      prolongation[0](44,37) = 135.0/4096.0;
+      prolongation[0](44,38) = -45.0/4096.0;
+      prolongation[0](44,39) = -45.0/4096.0;
+      prolongation[0](44,40) = 675.0/4096.0;
+      prolongation[0](44,41) = 675.0/4096.0;
+      prolongation[0](44,42) = -225.0/4096.0;
+      prolongation[0](44,43) = -225.0/4096.0;
+      prolongation[0](44,44) = -225.0/4096.0;
+      prolongation[0](44,45) = 75.0/4096.0;
+      prolongation[0](44,46) = 75.0/4096.0;
+      prolongation[0](44,47) = -25.0/4096.0;
+      prolongation[0](44,48) = 135.0/4096.0;
+      prolongation[0](44,49) = 135.0/4096.0;
+      prolongation[0](44,50) = -45.0/4096.0;
+      prolongation[0](44,51) = -45.0/4096.0;
+      prolongation[0](44,52) = -225.0/4096.0;
+      prolongation[0](44,53) = 75.0/4096.0;
+      prolongation[0](44,54) = 75.0/4096.0;
+      prolongation[0](44,55) = -25.0/4096.0;
+      prolongation[0](44,56) = 2025.0/4096.0;
+      prolongation[0](44,57) = 2025.0/4096.0;
+      prolongation[0](44,58) = -675.0/4096.0;
+      prolongation[0](44,59) = -675.0/4096.0;
+      prolongation[0](44,60) = -675.0/4096.0;
+      prolongation[0](44,61) = -675.0/4096.0;
+      prolongation[0](44,62) = 225.0/4096.0;
+      prolongation[0](44,63) = 225.0/4096.0;
+      prolongation[0](45,24) = -5.0/256.0;
+      prolongation[0](45,26) = -5.0/256.0;
+      prolongation[0](45,28) = -1.0/256.0;
+      prolongation[0](45,30) = -1.0/256.0;
+      prolongation[0](45,40) = 45.0/256.0;
+      prolongation[0](45,41) = 45.0/256.0;
+      prolongation[0](45,44) = -15.0/256.0;
+      prolongation[0](45,46) = 5.0/256.0;
+      prolongation[0](45,48) = 9.0/256.0;
+      prolongation[0](45,49) = 9.0/256.0;
+      prolongation[0](45,52) = -15.0/256.0;
+      prolongation[0](45,54) = 5.0/256.0;
+      prolongation[0](45,56) = 135.0/256.0;
+      prolongation[0](45,57) = 135.0/256.0;
+      prolongation[0](45,60) = -45.0/256.0;
+      prolongation[0](45,61) = -45.0/256.0;
+      prolongation[0](46,10) = -5.0/256.0;
+      prolongation[0](46,14) = -5.0/256.0;
+      prolongation[0](46,18) = -1.0/256.0;
+      prolongation[0](46,22) = -1.0/256.0;
+      prolongation[0](46,32) = 45.0/256.0;
+      prolongation[0](46,33) = 45.0/256.0;
+      prolongation[0](46,36) = 9.0/256.0;
+      prolongation[0](46,37) = 9.0/256.0;
+      prolongation[0](46,44) = -15.0/256.0;
+      prolongation[0](46,45) = 5.0/256.0;
+      prolongation[0](46,52) = -15.0/256.0;
+      prolongation[0](46,53) = 5.0/256.0;
+      prolongation[0](46,56) = 135.0/256.0;
+      prolongation[0](46,57) = 135.0/256.0;
+      prolongation[0](46,58) = -45.0/256.0;
+      prolongation[0](46,59) = -45.0/256.0;
+      prolongation[0](47,44) = -1.0/16.0;
+      prolongation[0](47,52) = -1.0/16.0;
+      prolongation[0](47,56) = 9.0/16.0;
+      prolongation[0](47,57) = 9.0/16.0;
+      prolongation[0](48,0) = -25.0/4096.0;
+      prolongation[0](48,1) = -5.0/4096.0;
+      prolongation[0](48,2) = -5.0/4096.0;
+      prolongation[0](48,3) = -25.0/4096.0;
+      prolongation[0](48,4) = -5.0/4096.0;
+      prolongation[0](48,5) = -1.0/4096.0;
+      prolongation[0](48,6) = -1.0/4096.0;
+      prolongation[0](48,7) = -5.0/4096.0;
+      prolongation[0](48,8) = -75.0/4096.0;
+      prolongation[0](48,9) = 25.0/4096.0;
+      prolongation[0](48,10) = 45.0/4096.0;
+      prolongation[0](48,11) = 45.0/4096.0;
+      prolongation[0](48,12) = -75.0/4096.0;
+      prolongation[0](48,13) = 25.0/4096.0;
+      prolongation[0](48,14) = 225.0/4096.0;
+      prolongation[0](48,15) = 225.0/4096.0;
+      prolongation[0](48,16) = -15.0/4096.0;
+      prolongation[0](48,17) = 5.0/4096.0;
+      prolongation[0](48,18) = 9.0/4096.0;
+      prolongation[0](48,19) = 9.0/4096.0;
+      prolongation[0](48,20) = -15.0/4096.0;
+      prolongation[0](48,21) = 5.0/4096.0;
+      prolongation[0](48,22) = 45.0/4096.0;
+      prolongation[0](48,23) = 45.0/4096.0;
+      prolongation[0](48,24) = -75.0/4096.0;
+      prolongation[0](48,25) = 25.0/4096.0;
+      prolongation[0](48,26) = -15.0/4096.0;
+      prolongation[0](48,27) = 5.0/4096.0;
+      prolongation[0](48,28) = -15.0/4096.0;
+      prolongation[0](48,29) = 5.0/4096.0;
+      prolongation[0](48,30) = -75.0/4096.0;
+      prolongation[0](48,31) = 25.0/4096.0;
+      prolongation[0](48,32) = 675.0/4096.0;
+      prolongation[0](48,33) = -225.0/4096.0;
+      prolongation[0](48,34) = 675.0/4096.0;
+      prolongation[0](48,35) = -225.0/4096.0;
+      prolongation[0](48,36) = 135.0/4096.0;
+      prolongation[0](48,37) = -45.0/4096.0;
+      prolongation[0](48,38) = 135.0/4096.0;
+      prolongation[0](48,39) = -45.0/4096.0;
+      prolongation[0](48,40) = -225.0/4096.0;
+      prolongation[0](48,41) = 75.0/4096.0;
+      prolongation[0](48,42) = 75.0/4096.0;
+      prolongation[0](48,43) = -25.0/4096.0;
+      prolongation[0](48,44) = 135.0/4096.0;
+      prolongation[0](48,45) = -45.0/4096.0;
+      prolongation[0](48,46) = 135.0/4096.0;
+      prolongation[0](48,47) = -45.0/4096.0;
+      prolongation[0](48,48) = -225.0/4096.0;
+      prolongation[0](48,49) = 75.0/4096.0;
+      prolongation[0](48,50) = 75.0/4096.0;
+      prolongation[0](48,51) = -25.0/4096.0;
+      prolongation[0](48,52) = 675.0/4096.0;
+      prolongation[0](48,53) = -225.0/4096.0;
+      prolongation[0](48,54) = 675.0/4096.0;
+      prolongation[0](48,55) = -225.0/4096.0;
+      prolongation[0](48,56) = 2025.0/4096.0;
+      prolongation[0](48,57) = -675.0/4096.0;
+      prolongation[0](48,58) = -675.0/4096.0;
+      prolongation[0](48,59) = 225.0/4096.0;
+      prolongation[0](48,60) = 2025.0/4096.0;
+      prolongation[0](48,61) = -675.0/4096.0;
+      prolongation[0](48,62) = -675.0/4096.0;
+      prolongation[0](48,63) = 225.0/4096.0;
+      prolongation[0](49,8) = -5.0/256.0;
+      prolongation[0](49,12) = -5.0/256.0;
+      prolongation[0](49,16) = -1.0/256.0;
+      prolongation[0](49,20) = -1.0/256.0;
+      prolongation[0](49,32) = 45.0/256.0;
+      prolongation[0](49,34) = 45.0/256.0;
+      prolongation[0](49,36) = 9.0/256.0;
+      prolongation[0](49,38) = 9.0/256.0;
+      prolongation[0](49,40) = -15.0/256.0;
+      prolongation[0](49,42) = 5.0/256.0;
+      prolongation[0](49,48) = -15.0/256.0;
+      prolongation[0](49,50) = 5.0/256.0;
+      prolongation[0](49,56) = 135.0/256.0;
+      prolongation[0](49,58) = -45.0/256.0;
+      prolongation[0](49,60) = 135.0/256.0;
+      prolongation[0](49,62) = -45.0/256.0;
+      prolongation[0](50,24) = -5.0/256.0;
+      prolongation[0](50,26) = -1.0/256.0;
+      prolongation[0](50,28) = -1.0/256.0;
+      prolongation[0](50,30) = -5.0/256.0;
+      prolongation[0](50,40) = -15.0/256.0;
+      prolongation[0](50,41) = 5.0/256.0;
+      prolongation[0](50,44) = 9.0/256.0;
+      prolongation[0](50,46) = 9.0/256.0;
+      prolongation[0](50,48) = -15.0/256.0;
+      prolongation[0](50,49) = 5.0/256.0;
+      prolongation[0](50,52) = 45.0/256.0;
+      prolongation[0](50,54) = 45.0/256.0;
+      prolongation[0](50,56) = 135.0/256.0;
+      prolongation[0](50,57) = -45.0/256.0;
+      prolongation[0](50,60) = 135.0/256.0;
+      prolongation[0](50,61) = -45.0/256.0;
+      prolongation[0](51,40) = -1.0/16.0;
+      prolongation[0](51,48) = -1.0/16.0;
+      prolongation[0](51,56) = 9.0/16.0;
+      prolongation[0](51,60) = 9.0/16.0;
+      prolongation[0](52,0) = 25.0/256.0;
+      prolongation[0](52,3) = 5.0/256.0;
+      prolongation[0](52,4) = 5.0/256.0;
+      prolongation[0](52,7) = 1.0/256.0;
+      prolongation[0](52,14) = 75.0/256.0;
+      prolongation[0](52,15) = -25.0/256.0;
+      prolongation[0](52,22) = 15.0/256.0;
+      prolongation[0](52,23) = -5.0/256.0;
+      prolongation[0](52,24) = 75.0/256.0;
+      prolongation[0](52,25) = -25.0/256.0;
+      prolongation[0](52,30) = 15.0/256.0;
+      prolongation[0](52,31) = -5.0/256.0;
+      prolongation[0](52,52) = 225.0/256.0;
+      prolongation[0](52,53) = -75.0/256.0;
+      prolongation[0](52,54) = -75.0/256.0;
+      prolongation[0](52,55) = 25.0/256.0;
+      prolongation[0](53,24) = 5.0/16.0;
+      prolongation[0](53,30) = 1.0/16.0;
+      prolongation[0](53,52) = 15.0/16.0;
+      prolongation[0](53,54) = -5.0/16.0;
+      prolongation[0](54,14) = 5.0/16.0;
+      prolongation[0](54,22) = 1.0/16.0;
+      prolongation[0](54,52) = 15.0/16.0;
+      prolongation[0](54,53) = -5.0/16.0;
+      prolongation[0](55,52) = 1.0;
+      prolongation[0](56,0) = 125.0/4096.0;
+      prolongation[0](56,1) = 25.0/4096.0;
+      prolongation[0](56,2) = 5.0/4096.0;
+      prolongation[0](56,3) = 25.0/4096.0;
+      prolongation[0](56,4) = 25.0/4096.0;
+      prolongation[0](56,5) = 5.0/4096.0;
+      prolongation[0](56,6) = 1.0/4096.0;
+      prolongation[0](56,7) = 5.0/4096.0;
+      prolongation[0](56,8) = 375.0/4096.0;
+      prolongation[0](56,9) = -125.0/4096.0;
+      prolongation[0](56,10) = 75.0/4096.0;
+      prolongation[0](56,11) = -25.0/4096.0;
+      prolongation[0](56,12) = 75.0/4096.0;
+      prolongation[0](56,13) = -25.0/4096.0;
+      prolongation[0](56,14) = 375.0/4096.0;
+      prolongation[0](56,15) = -125.0/4096.0;
+      prolongation[0](56,16) = 75.0/4096.0;
+      prolongation[0](56,17) = -25.0/4096.0;
+      prolongation[0](56,18) = 15.0/4096.0;
+      prolongation[0](56,19) = -5.0/4096.0;
+      prolongation[0](56,20) = 15.0/4096.0;
+      prolongation[0](56,21) = -5.0/4096.0;
+      prolongation[0](56,22) = 75.0/4096.0;
+      prolongation[0](56,23) = -25.0/4096.0;
+      prolongation[0](56,24) = 375.0/4096.0;
+      prolongation[0](56,25) = -125.0/4096.0;
+      prolongation[0](56,26) = 75.0/4096.0;
+      prolongation[0](56,27) = -25.0/4096.0;
+      prolongation[0](56,28) = 15.0/4096.0;
+      prolongation[0](56,29) = -5.0/4096.0;
+      prolongation[0](56,30) = 75.0/4096.0;
+      prolongation[0](56,31) = -25.0/4096.0;
+      prolongation[0](56,32) = 1125.0/4096.0;
+      prolongation[0](56,33) = -375.0/4096.0;
+      prolongation[0](56,34) = -375.0/4096.0;
+      prolongation[0](56,35) = 125.0/4096.0;
+      prolongation[0](56,36) = 225.0/4096.0;
+      prolongation[0](56,37) = -75.0/4096.0;
+      prolongation[0](56,38) = -75.0/4096.0;
+      prolongation[0](56,39) = 25.0/4096.0;
+      prolongation[0](56,40) = 1125.0/4096.0;
+      prolongation[0](56,41) = -375.0/4096.0;
+      prolongation[0](56,42) = -375.0/4096.0;
+      prolongation[0](56,43) = 125.0/4096.0;
+      prolongation[0](56,44) = 225.0/4096.0;
+      prolongation[0](56,45) = -75.0/4096.0;
+      prolongation[0](56,46) = -75.0/4096.0;
+      prolongation[0](56,47) = 25.0/4096.0;
+      prolongation[0](56,48) = 225.0/4096.0;
+      prolongation[0](56,49) = -75.0/4096.0;
+      prolongation[0](56,50) = -75.0/4096.0;
+      prolongation[0](56,51) = 25.0/4096.0;
+      prolongation[0](56,52) = 1125.0/4096.0;
+      prolongation[0](56,53) = -375.0/4096.0;
+      prolongation[0](56,54) = -375.0/4096.0;
+      prolongation[0](56,55) = 125.0/4096.0;
+      prolongation[0](56,56) = 3375.0/4096.0;
+      prolongation[0](56,57) = -1125.0/4096.0;
+      prolongation[0](56,58) = -1125.0/4096.0;
+      prolongation[0](56,59) = 375.0/4096.0;
+      prolongation[0](56,60) = -1125.0/4096.0;
+      prolongation[0](56,61) = 375.0/4096.0;
+      prolongation[0](56,62) = 375.0/4096.0;
+      prolongation[0](56,63) = -125.0/4096.0;
+      prolongation[0](57,8) = 25.0/256.0;
+      prolongation[0](57,12) = 5.0/256.0;
+      prolongation[0](57,16) = 5.0/256.0;
+      prolongation[0](57,20) = 1.0/256.0;
+      prolongation[0](57,32) = 75.0/256.0;
+      prolongation[0](57,34) = -25.0/256.0;
+      prolongation[0](57,36) = 15.0/256.0;
+      prolongation[0](57,38) = -5.0/256.0;
+      prolongation[0](57,40) = 75.0/256.0;
+      prolongation[0](57,42) = -25.0/256.0;
+      prolongation[0](57,48) = 15.0/256.0;
+      prolongation[0](57,50) = -5.0/256.0;
+      prolongation[0](57,56) = 225.0/256.0;
+      prolongation[0](57,58) = -75.0/256.0;
+      prolongation[0](57,60) = -75.0/256.0;
+      prolongation[0](57,62) = 25.0/256.0;
+      prolongation[0](58,24) = 25.0/256.0;
+      prolongation[0](58,26) = 5.0/256.0;
+      prolongation[0](58,28) = 1.0/256.0;
+      prolongation[0](58,30) = 5.0/256.0;
+      prolongation[0](58,40) = 75.0/256.0;
+      prolongation[0](58,41) = -25.0/256.0;
+      prolongation[0](58,44) = 15.0/256.0;
+      prolongation[0](58,46) = -5.0/256.0;
+      prolongation[0](58,48) = 15.0/256.0;
+      prolongation[0](58,49) = -5.0/256.0;
+      prolongation[0](58,52) = 75.0/256.0;
+      prolongation[0](58,54) = -25.0/256.0;
+      prolongation[0](58,56) = 225.0/256.0;
+      prolongation[0](58,57) = -75.0/256.0;
+      prolongation[0](58,60) = -75.0/256.0;
+      prolongation[0](58,61) = 25.0/256.0;
+      prolongation[0](59,40) = 5.0/16.0;
+      prolongation[0](59,48) = 1.0/16.0;
+      prolongation[0](59,56) = 15.0/16.0;
+      prolongation[0](59,60) = -5.0/16.0;
+      prolongation[0](60,10) = 5.0/256.0;
+      prolongation[0](60,14) = 25.0/256.0;
+      prolongation[0](60,18) = 1.0/256.0;
+      prolongation[0](60,22) = 5.0/256.0;
+      prolongation[0](60,32) = 75.0/256.0;
+      prolongation[0](60,33) = -25.0/256.0;
+      prolongation[0](60,36) = 15.0/256.0;
+      prolongation[0](60,37) = -5.0/256.0;
+      prolongation[0](60,44) = 15.0/256.0;
+      prolongation[0](60,45) = -5.0/256.0;
+      prolongation[0](60,52) = 75.0/256.0;
+      prolongation[0](60,53) = -25.0/256.0;
+      prolongation[0](60,56) = 225.0/256.0;
+      prolongation[0](60,57) = -75.0/256.0;
+      prolongation[0](60,58) = -75.0/256.0;
+      prolongation[0](60,59) = 25.0/256.0;
+      prolongation[0](61,32) = 5.0/16.0;
+      prolongation[0](61,36) = 1.0/16.0;
+      prolongation[0](61,56) = 15.0/16.0;
+      prolongation[0](61,58) = -5.0/16.0;
+      prolongation[0](62,44) = 1.0/16.0;
+      prolongation[0](62,52) = 5.0/16.0;
+      prolongation[0](62,56) = 15.0/16.0;
+      prolongation[0](62,57) = -5.0/16.0;
+      prolongation[0](63,56) = 1.0;
+      prolongation[1](0,0) = -1.0/16.0;
+      prolongation[1](0,1) = -1.0/16.0;
+      prolongation[1](0,8) = 9.0/16.0;
+      prolongation[1](0,9) = 9.0/16.0;
+      prolongation[1](1,1) = 1.0;
+      prolongation[1](2,1) = -1.0/16.0;
+      prolongation[1](2,2) = -1.0/16.0;
+      prolongation[1](2,10) = 9.0/16.0;
+      prolongation[1](2,11) = 9.0/16.0;
+      prolongation[1](3,0) = 1.0/256.0;
+      prolongation[1](3,1) = 1.0/256.0;
+      prolongation[1](3,2) = 1.0/256.0;
+      prolongation[1](3,3) = 1.0/256.0;
+      prolongation[1](3,8) = -9.0/256.0;
+      prolongation[1](3,9) = -9.0/256.0;
+      prolongation[1](3,10) = -9.0/256.0;
+      prolongation[1](3,11) = -9.0/256.0;
+      prolongation[1](3,12) = -9.0/256.0;
+      prolongation[1](3,13) = -9.0/256.0;
+      prolongation[1](3,14) = -9.0/256.0;
+      prolongation[1](3,15) = -9.0/256.0;
+      prolongation[1](3,32) = 81.0/256.0;
+      prolongation[1](3,33) = 81.0/256.0;
+      prolongation[1](3,34) = 81.0/256.0;
+      prolongation[1](3,35) = 81.0/256.0;
+      prolongation[1](4,0) = 1.0/256.0;
+      prolongation[1](4,1) = 1.0/256.0;
+      prolongation[1](4,4) = 1.0/256.0;
+      prolongation[1](4,5) = 1.0/256.0;
+      prolongation[1](4,8) = -9.0/256.0;
+      prolongation[1](4,9) = -9.0/256.0;
+      prolongation[1](4,16) = -9.0/256.0;
+      prolongation[1](4,17) = -9.0/256.0;
+      prolongation[1](4,24) = -9.0/256.0;
+      prolongation[1](4,25) = -9.0/256.0;
+      prolongation[1](4,26) = -9.0/256.0;
+      prolongation[1](4,27) = -9.0/256.0;
+      prolongation[1](4,40) = 81.0/256.0;
+      prolongation[1](4,41) = 81.0/256.0;
+      prolongation[1](4,42) = 81.0/256.0;
+      prolongation[1](4,43) = 81.0/256.0;
+      prolongation[1](5,1) = -1.0/16.0;
+      prolongation[1](5,5) = -1.0/16.0;
+      prolongation[1](5,26) = 9.0/16.0;
+      prolongation[1](5,27) = 9.0/16.0;
+      prolongation[1](6,1) = 1.0/256.0;
+      prolongation[1](6,2) = 1.0/256.0;
+      prolongation[1](6,5) = 1.0/256.0;
+      prolongation[1](6,6) = 1.0/256.0;
+      prolongation[1](6,10) = -9.0/256.0;
+      prolongation[1](6,11) = -9.0/256.0;
+      prolongation[1](6,18) = -9.0/256.0;
+      prolongation[1](6,19) = -9.0/256.0;
+      prolongation[1](6,26) = -9.0/256.0;
+      prolongation[1](6,27) = -9.0/256.0;
+      prolongation[1](6,28) = -9.0/256.0;
+      prolongation[1](6,29) = -9.0/256.0;
+      prolongation[1](6,44) = 81.0/256.0;
+      prolongation[1](6,45) = 81.0/256.0;
+      prolongation[1](6,46) = 81.0/256.0;
+      prolongation[1](6,47) = 81.0/256.0;
+      prolongation[1](7,0) = -1.0/4096.0;
+      prolongation[1](7,1) = -1.0/4096.0;
+      prolongation[1](7,2) = -1.0/4096.0;
+      prolongation[1](7,3) = -1.0/4096.0;
+      prolongation[1](7,4) = -1.0/4096.0;
+      prolongation[1](7,5) = -1.0/4096.0;
+      prolongation[1](7,6) = -1.0/4096.0;
+      prolongation[1](7,7) = -1.0/4096.0;
+      prolongation[1](7,8) = 9.0/4096.0;
+      prolongation[1](7,9) = 9.0/4096.0;
+      prolongation[1](7,10) = 9.0/4096.0;
+      prolongation[1](7,11) = 9.0/4096.0;
+      prolongation[1](7,12) = 9.0/4096.0;
+      prolongation[1](7,13) = 9.0/4096.0;
+      prolongation[1](7,14) = 9.0/4096.0;
+      prolongation[1](7,15) = 9.0/4096.0;
+      prolongation[1](7,16) = 9.0/4096.0;
+      prolongation[1](7,17) = 9.0/4096.0;
+      prolongation[1](7,18) = 9.0/4096.0;
+      prolongation[1](7,19) = 9.0/4096.0;
+      prolongation[1](7,20) = 9.0/4096.0;
+      prolongation[1](7,21) = 9.0/4096.0;
+      prolongation[1](7,22) = 9.0/4096.0;
+      prolongation[1](7,23) = 9.0/4096.0;
+      prolongation[1](7,24) = 9.0/4096.0;
+      prolongation[1](7,25) = 9.0/4096.0;
+      prolongation[1](7,26) = 9.0/4096.0;
+      prolongation[1](7,27) = 9.0/4096.0;
+      prolongation[1](7,28) = 9.0/4096.0;
+      prolongation[1](7,29) = 9.0/4096.0;
+      prolongation[1](7,30) = 9.0/4096.0;
+      prolongation[1](7,31) = 9.0/4096.0;
+      prolongation[1](7,32) = -81.0/4096.0;
+      prolongation[1](7,33) = -81.0/4096.0;
+      prolongation[1](7,34) = -81.0/4096.0;
+      prolongation[1](7,35) = -81.0/4096.0;
+      prolongation[1](7,36) = -81.0/4096.0;
+      prolongation[1](7,37) = -81.0/4096.0;
+      prolongation[1](7,38) = -81.0/4096.0;
+      prolongation[1](7,39) = -81.0/4096.0;
+      prolongation[1](7,40) = -81.0/4096.0;
+      prolongation[1](7,41) = -81.0/4096.0;
+      prolongation[1](7,42) = -81.0/4096.0;
+      prolongation[1](7,43) = -81.0/4096.0;
+      prolongation[1](7,44) = -81.0/4096.0;
+      prolongation[1](7,45) = -81.0/4096.0;
+      prolongation[1](7,46) = -81.0/4096.0;
+      prolongation[1](7,47) = -81.0/4096.0;
+      prolongation[1](7,48) = -81.0/4096.0;
+      prolongation[1](7,49) = -81.0/4096.0;
+      prolongation[1](7,50) = -81.0/4096.0;
+      prolongation[1](7,51) = -81.0/4096.0;
+      prolongation[1](7,52) = -81.0/4096.0;
+      prolongation[1](7,53) = -81.0/4096.0;
+      prolongation[1](7,54) = -81.0/4096.0;
+      prolongation[1](7,55) = -81.0/4096.0;
+      prolongation[1](7,56) = 729.0/4096.0;
+      prolongation[1](7,57) = 729.0/4096.0;
+      prolongation[1](7,58) = 729.0/4096.0;
+      prolongation[1](7,59) = 729.0/4096.0;
+      prolongation[1](7,60) = 729.0/4096.0;
+      prolongation[1](7,61) = 729.0/4096.0;
+      prolongation[1](7,62) = 729.0/4096.0;
+      prolongation[1](7,63) = 729.0/4096.0;
+      prolongation[1](8,9) = 1.0;
+      prolongation[1](9,0) = 1.0/16.0;
+      prolongation[1](9,1) = 5.0/16.0;
+      prolongation[1](9,8) = -5.0/16.0;
+      prolongation[1](9,9) = 15.0/16.0;
+      prolongation[1](10,1) = 5.0/16.0;
+      prolongation[1](10,2) = 1.0/16.0;
+      prolongation[1](10,10) = 15.0/16.0;
+      prolongation[1](10,11) = -5.0/16.0;
+      prolongation[1](11,10) = 1.0;
+      prolongation[1](12,9) = -1.0/16.0;
+      prolongation[1](12,13) = -1.0/16.0;
+      prolongation[1](12,33) = 9.0/16.0;
+      prolongation[1](12,35) = 9.0/16.0;
+      prolongation[1](13,0) = -1.0/256.0;
+      prolongation[1](13,1) = -5.0/256.0;
+      prolongation[1](13,2) = -5.0/256.0;
+      prolongation[1](13,3) = -1.0/256.0;
+      prolongation[1](13,8) = 5.0/256.0;
+      prolongation[1](13,9) = -15.0/256.0;
+      prolongation[1](13,10) = 45.0/256.0;
+      prolongation[1](13,11) = 45.0/256.0;
+      prolongation[1](13,12) = 5.0/256.0;
+      prolongation[1](13,13) = -15.0/256.0;
+      prolongation[1](13,14) = 9.0/256.0;
+      prolongation[1](13,15) = 9.0/256.0;
+      prolongation[1](13,32) = -45.0/256.0;
+      prolongation[1](13,33) = 135.0/256.0;
+      prolongation[1](13,34) = -45.0/256.0;
+      prolongation[1](13,35) = 135.0/256.0;
+      prolongation[1](14,0) = -5.0/256.0;
+      prolongation[1](14,1) = -5.0/256.0;
+      prolongation[1](14,2) = -1.0/256.0;
+      prolongation[1](14,3) = -1.0/256.0;
+      prolongation[1](14,8) = 45.0/256.0;
+      prolongation[1](14,9) = 45.0/256.0;
+      prolongation[1](14,10) = -15.0/256.0;
+      prolongation[1](14,11) = 5.0/256.0;
+      prolongation[1](14,12) = 9.0/256.0;
+      prolongation[1](14,13) = 9.0/256.0;
+      prolongation[1](14,14) = -15.0/256.0;
+      prolongation[1](14,15) = 5.0/256.0;
+      prolongation[1](14,32) = 135.0/256.0;
+      prolongation[1](14,33) = 135.0/256.0;
+      prolongation[1](14,34) = -45.0/256.0;
+      prolongation[1](14,35) = -45.0/256.0;
+      prolongation[1](15,10) = -1.0/16.0;
+      prolongation[1](15,14) = -1.0/16.0;
+      prolongation[1](15,32) = 9.0/16.0;
+      prolongation[1](15,33) = 9.0/16.0;
+      prolongation[1](16,9) = -1.0/16.0;
+      prolongation[1](16,17) = -1.0/16.0;
+      prolongation[1](16,41) = 9.0/16.0;
+      prolongation[1](16,43) = 9.0/16.0;
+      prolongation[1](17,0) = -1.0/256.0;
+      prolongation[1](17,1) = -5.0/256.0;
+      prolongation[1](17,4) = -1.0/256.0;
+      prolongation[1](17,5) = -5.0/256.0;
+      prolongation[1](17,8) = 5.0/256.0;
+      prolongation[1](17,9) = -15.0/256.0;
+      prolongation[1](17,16) = 5.0/256.0;
+      prolongation[1](17,17) = -15.0/256.0;
+      prolongation[1](17,24) = 9.0/256.0;
+      prolongation[1](17,25) = 9.0/256.0;
+      prolongation[1](17,26) = 45.0/256.0;
+      prolongation[1](17,27) = 45.0/256.0;
+      prolongation[1](17,40) = -45.0/256.0;
+      prolongation[1](17,41) = 135.0/256.0;
+      prolongation[1](17,42) = -45.0/256.0;
+      prolongation[1](17,43) = 135.0/256.0;
+      prolongation[1](18,1) = -5.0/256.0;
+      prolongation[1](18,2) = -1.0/256.0;
+      prolongation[1](18,5) = -5.0/256.0;
+      prolongation[1](18,6) = -1.0/256.0;
+      prolongation[1](18,10) = -15.0/256.0;
+      prolongation[1](18,11) = 5.0/256.0;
+      prolongation[1](18,18) = -15.0/256.0;
+      prolongation[1](18,19) = 5.0/256.0;
+      prolongation[1](18,26) = 45.0/256.0;
+      prolongation[1](18,27) = 45.0/256.0;
+      prolongation[1](18,28) = 9.0/256.0;
+      prolongation[1](18,29) = 9.0/256.0;
+      prolongation[1](18,44) = 135.0/256.0;
+      prolongation[1](18,45) = 135.0/256.0;
+      prolongation[1](18,46) = -45.0/256.0;
+      prolongation[1](18,47) = -45.0/256.0;
+      prolongation[1](19,10) = -1.0/16.0;
+      prolongation[1](19,18) = -1.0/16.0;
+      prolongation[1](19,44) = 9.0/16.0;
+      prolongation[1](19,45) = 9.0/16.0;
+      prolongation[1](20,9) = 1.0/256.0;
+      prolongation[1](20,13) = 1.0/256.0;
+      prolongation[1](20,17) = 1.0/256.0;
+      prolongation[1](20,21) = 1.0/256.0;
+      prolongation[1](20,33) = -9.0/256.0;
+      prolongation[1](20,35) = -9.0/256.0;
+      prolongation[1](20,37) = -9.0/256.0;
+      prolongation[1](20,39) = -9.0/256.0;
+      prolongation[1](20,41) = -9.0/256.0;
+      prolongation[1](20,43) = -9.0/256.0;
+      prolongation[1](20,49) = -9.0/256.0;
+      prolongation[1](20,51) = -9.0/256.0;
+      prolongation[1](20,57) = 81.0/256.0;
+      prolongation[1](20,59) = 81.0/256.0;
+      prolongation[1](20,61) = 81.0/256.0;
+      prolongation[1](20,63) = 81.0/256.0;
+      prolongation[1](21,0) = 1.0/4096.0;
+      prolongation[1](21,1) = 5.0/4096.0;
+      prolongation[1](21,2) = 5.0/4096.0;
+      prolongation[1](21,3) = 1.0/4096.0;
+      prolongation[1](21,4) = 1.0/4096.0;
+      prolongation[1](21,5) = 5.0/4096.0;
+      prolongation[1](21,6) = 5.0/4096.0;
+      prolongation[1](21,7) = 1.0/4096.0;
+      prolongation[1](21,8) = -5.0/4096.0;
+      prolongation[1](21,9) = 15.0/4096.0;
+      prolongation[1](21,10) = -45.0/4096.0;
+      prolongation[1](21,11) = -45.0/4096.0;
+      prolongation[1](21,12) = -5.0/4096.0;
+      prolongation[1](21,13) = 15.0/4096.0;
+      prolongation[1](21,14) = -9.0/4096.0;
+      prolongation[1](21,15) = -9.0/4096.0;
+      prolongation[1](21,16) = -5.0/4096.0;
+      prolongation[1](21,17) = 15.0/4096.0;
+      prolongation[1](21,18) = -45.0/4096.0;
+      prolongation[1](21,19) = -45.0/4096.0;
+      prolongation[1](21,20) = -5.0/4096.0;
+      prolongation[1](21,21) = 15.0/4096.0;
+      prolongation[1](21,22) = -9.0/4096.0;
+      prolongation[1](21,23) = -9.0/4096.0;
+      prolongation[1](21,24) = -9.0/4096.0;
+      prolongation[1](21,25) = -9.0/4096.0;
+      prolongation[1](21,26) = -45.0/4096.0;
+      prolongation[1](21,27) = -45.0/4096.0;
+      prolongation[1](21,28) = -45.0/4096.0;
+      prolongation[1](21,29) = -45.0/4096.0;
+      prolongation[1](21,30) = -9.0/4096.0;
+      prolongation[1](21,31) = -9.0/4096.0;
+      prolongation[1](21,32) = 45.0/4096.0;
+      prolongation[1](21,33) = -135.0/4096.0;
+      prolongation[1](21,34) = 45.0/4096.0;
+      prolongation[1](21,35) = -135.0/4096.0;
+      prolongation[1](21,36) = 45.0/4096.0;
+      prolongation[1](21,37) = -135.0/4096.0;
+      prolongation[1](21,38) = 45.0/4096.0;
+      prolongation[1](21,39) = -135.0/4096.0;
+      prolongation[1](21,40) = 45.0/4096.0;
+      prolongation[1](21,41) = -135.0/4096.0;
+      prolongation[1](21,42) = 45.0/4096.0;
+      prolongation[1](21,43) = -135.0/4096.0;
+      prolongation[1](21,44) = 405.0/4096.0;
+      prolongation[1](21,45) = 405.0/4096.0;
+      prolongation[1](21,46) = 405.0/4096.0;
+      prolongation[1](21,47) = 405.0/4096.0;
+      prolongation[1](21,48) = 45.0/4096.0;
+      prolongation[1](21,49) = -135.0/4096.0;
+      prolongation[1](21,50) = 45.0/4096.0;
+      prolongation[1](21,51) = -135.0/4096.0;
+      prolongation[1](21,52) = 81.0/4096.0;
+      prolongation[1](21,53) = 81.0/4096.0;
+      prolongation[1](21,54) = 81.0/4096.0;
+      prolongation[1](21,55) = 81.0/4096.0;
+      prolongation[1](21,56) = -405.0/4096.0;
+      prolongation[1](21,57) = 1215.0/4096.0;
+      prolongation[1](21,58) = -405.0/4096.0;
+      prolongation[1](21,59) = 1215.0/4096.0;
+      prolongation[1](21,60) = -405.0/4096.0;
+      prolongation[1](21,61) = 1215.0/4096.0;
+      prolongation[1](21,62) = -405.0/4096.0;
+      prolongation[1](21,63) = 1215.0/4096.0;
+      prolongation[1](22,0) = 5.0/4096.0;
+      prolongation[1](22,1) = 5.0/4096.0;
+      prolongation[1](22,2) = 1.0/4096.0;
+      prolongation[1](22,3) = 1.0/4096.0;
+      prolongation[1](22,4) = 5.0/4096.0;
+      prolongation[1](22,5) = 5.0/4096.0;
+      prolongation[1](22,6) = 1.0/4096.0;
+      prolongation[1](22,7) = 1.0/4096.0;
+      prolongation[1](22,8) = -45.0/4096.0;
+      prolongation[1](22,9) = -45.0/4096.0;
+      prolongation[1](22,10) = 15.0/4096.0;
+      prolongation[1](22,11) = -5.0/4096.0;
+      prolongation[1](22,12) = -9.0/4096.0;
+      prolongation[1](22,13) = -9.0/4096.0;
+      prolongation[1](22,14) = 15.0/4096.0;
+      prolongation[1](22,15) = -5.0/4096.0;
+      prolongation[1](22,16) = -45.0/4096.0;
+      prolongation[1](22,17) = -45.0/4096.0;
+      prolongation[1](22,18) = 15.0/4096.0;
+      prolongation[1](22,19) = -5.0/4096.0;
+      prolongation[1](22,20) = -9.0/4096.0;
+      prolongation[1](22,21) = -9.0/4096.0;
+      prolongation[1](22,22) = 15.0/4096.0;
+      prolongation[1](22,23) = -5.0/4096.0;
+      prolongation[1](22,24) = -45.0/4096.0;
+      prolongation[1](22,25) = -45.0/4096.0;
+      prolongation[1](22,26) = -45.0/4096.0;
+      prolongation[1](22,27) = -45.0/4096.0;
+      prolongation[1](22,28) = -9.0/4096.0;
+      prolongation[1](22,29) = -9.0/4096.0;
+      prolongation[1](22,30) = -9.0/4096.0;
+      prolongation[1](22,31) = -9.0/4096.0;
+      prolongation[1](22,32) = -135.0/4096.0;
+      prolongation[1](22,33) = -135.0/4096.0;
+      prolongation[1](22,34) = 45.0/4096.0;
+      prolongation[1](22,35) = 45.0/4096.0;
+      prolongation[1](22,36) = -135.0/4096.0;
+      prolongation[1](22,37) = -135.0/4096.0;
+      prolongation[1](22,38) = 45.0/4096.0;
+      prolongation[1](22,39) = 45.0/4096.0;
+      prolongation[1](22,40) = 405.0/4096.0;
+      prolongation[1](22,41) = 405.0/4096.0;
+      prolongation[1](22,42) = 405.0/4096.0;
+      prolongation[1](22,43) = 405.0/4096.0;
+      prolongation[1](22,44) = -135.0/4096.0;
+      prolongation[1](22,45) = -135.0/4096.0;
+      prolongation[1](22,46) = 45.0/4096.0;
+      prolongation[1](22,47) = 45.0/4096.0;
+      prolongation[1](22,48) = 81.0/4096.0;
+      prolongation[1](22,49) = 81.0/4096.0;
+      prolongation[1](22,50) = 81.0/4096.0;
+      prolongation[1](22,51) = 81.0/4096.0;
+      prolongation[1](22,52) = -135.0/4096.0;
+      prolongation[1](22,53) = -135.0/4096.0;
+      prolongation[1](22,54) = 45.0/4096.0;
+      prolongation[1](22,55) = 45.0/4096.0;
+      prolongation[1](22,56) = 1215.0/4096.0;
+      prolongation[1](22,57) = 1215.0/4096.0;
+      prolongation[1](22,58) = 1215.0/4096.0;
+      prolongation[1](22,59) = 1215.0/4096.0;
+      prolongation[1](22,60) = -405.0/4096.0;
+      prolongation[1](22,61) = -405.0/4096.0;
+      prolongation[1](22,62) = -405.0/4096.0;
+      prolongation[1](22,63) = -405.0/4096.0;
+      prolongation[1](23,10) = 1.0/256.0;
+      prolongation[1](23,14) = 1.0/256.0;
+      prolongation[1](23,18) = 1.0/256.0;
+      prolongation[1](23,22) = 1.0/256.0;
+      prolongation[1](23,32) = -9.0/256.0;
+      prolongation[1](23,33) = -9.0/256.0;
+      prolongation[1](23,36) = -9.0/256.0;
+      prolongation[1](23,37) = -9.0/256.0;
+      prolongation[1](23,44) = -9.0/256.0;
+      prolongation[1](23,45) = -9.0/256.0;
+      prolongation[1](23,52) = -9.0/256.0;
+      prolongation[1](23,53) = -9.0/256.0;
+      prolongation[1](23,56) = 81.0/256.0;
+      prolongation[1](23,57) = 81.0/256.0;
+      prolongation[1](23,58) = 81.0/256.0;
+      prolongation[1](23,59) = 81.0/256.0;
+      prolongation[1](24,0) = -5.0/256.0;
+      prolongation[1](24,1) = -5.0/256.0;
+      prolongation[1](24,4) = -1.0/256.0;
+      prolongation[1](24,5) = -1.0/256.0;
+      prolongation[1](24,8) = 45.0/256.0;
+      prolongation[1](24,9) = 45.0/256.0;
+      prolongation[1](24,16) = 9.0/256.0;
+      prolongation[1](24,17) = 9.0/256.0;
+      prolongation[1](24,24) = -15.0/256.0;
+      prolongation[1](24,25) = 5.0/256.0;
+      prolongation[1](24,26) = -15.0/256.0;
+      prolongation[1](24,27) = 5.0/256.0;
+      prolongation[1](24,40) = 135.0/256.0;
+      prolongation[1](24,41) = 135.0/256.0;
+      prolongation[1](24,42) = -45.0/256.0;
+      prolongation[1](24,43) = -45.0/256.0;
+      prolongation[1](25,24) = -1.0/16.0;
+      prolongation[1](25,26) = -1.0/16.0;
+      prolongation[1](25,40) = 9.0/16.0;
+      prolongation[1](25,41) = 9.0/16.0;
+      prolongation[1](26,1) = 5.0/16.0;
+      prolongation[1](26,5) = 1.0/16.0;
+      prolongation[1](26,26) = 15.0/16.0;
+      prolongation[1](26,27) = -5.0/16.0;
+      prolongation[1](27,26) = 1.0;
+      prolongation[1](28,1) = -5.0/256.0;
+      prolongation[1](28,2) = -5.0/256.0;
+      prolongation[1](28,5) = -1.0/256.0;
+      prolongation[1](28,6) = -1.0/256.0;
+      prolongation[1](28,10) = 45.0/256.0;
+      prolongation[1](28,11) = 45.0/256.0;
+      prolongation[1](28,18) = 9.0/256.0;
+      prolongation[1](28,19) = 9.0/256.0;
+      prolongation[1](28,26) = -15.0/256.0;
+      prolongation[1](28,27) = 5.0/256.0;
+      prolongation[1](28,28) = -15.0/256.0;
+      prolongation[1](28,29) = 5.0/256.0;
+      prolongation[1](28,44) = 135.0/256.0;
+      prolongation[1](28,45) = -45.0/256.0;
+      prolongation[1](28,46) = 135.0/256.0;
+      prolongation[1](28,47) = -45.0/256.0;
+      prolongation[1](29,26) = -1.0/16.0;
+      prolongation[1](29,28) = -1.0/16.0;
+      prolongation[1](29,44) = 9.0/16.0;
+      prolongation[1](29,46) = 9.0/16.0;
+      prolongation[1](30,0) = 5.0/4096.0;
+      prolongation[1](30,1) = 5.0/4096.0;
+      prolongation[1](30,2) = 5.0/4096.0;
+      prolongation[1](30,3) = 5.0/4096.0;
+      prolongation[1](30,4) = 1.0/4096.0;
+      prolongation[1](30,5) = 1.0/4096.0;
+      prolongation[1](30,6) = 1.0/4096.0;
+      prolongation[1](30,7) = 1.0/4096.0;
+      prolongation[1](30,8) = -45.0/4096.0;
+      prolongation[1](30,9) = -45.0/4096.0;
+      prolongation[1](30,10) = -45.0/4096.0;
+      prolongation[1](30,11) = -45.0/4096.0;
+      prolongation[1](30,12) = -45.0/4096.0;
+      prolongation[1](30,13) = -45.0/4096.0;
+      prolongation[1](30,14) = -45.0/4096.0;
+      prolongation[1](30,15) = -45.0/4096.0;
+      prolongation[1](30,16) = -9.0/4096.0;
+      prolongation[1](30,17) = -9.0/4096.0;
+      prolongation[1](30,18) = -9.0/4096.0;
+      prolongation[1](30,19) = -9.0/4096.0;
+      prolongation[1](30,20) = -9.0/4096.0;
+      prolongation[1](30,21) = -9.0/4096.0;
+      prolongation[1](30,22) = -9.0/4096.0;
+      prolongation[1](30,23) = -9.0/4096.0;
+      prolongation[1](30,24) = 15.0/4096.0;
+      prolongation[1](30,25) = -5.0/4096.0;
+      prolongation[1](30,26) = 15.0/4096.0;
+      prolongation[1](30,27) = -5.0/4096.0;
+      prolongation[1](30,28) = 15.0/4096.0;
+      prolongation[1](30,29) = -5.0/4096.0;
+      prolongation[1](30,30) = 15.0/4096.0;
+      prolongation[1](30,31) = -5.0/4096.0;
+      prolongation[1](30,32) = 405.0/4096.0;
+      prolongation[1](30,33) = 405.0/4096.0;
+      prolongation[1](30,34) = 405.0/4096.0;
+      prolongation[1](30,35) = 405.0/4096.0;
+      prolongation[1](30,36) = 81.0/4096.0;
+      prolongation[1](30,37) = 81.0/4096.0;
+      prolongation[1](30,38) = 81.0/4096.0;
+      prolongation[1](30,39) = 81.0/4096.0;
+      prolongation[1](30,40) = -135.0/4096.0;
+      prolongation[1](30,41) = -135.0/4096.0;
+      prolongation[1](30,42) = 45.0/4096.0;
+      prolongation[1](30,43) = 45.0/4096.0;
+      prolongation[1](30,44) = -135.0/4096.0;
+      prolongation[1](30,45) = 45.0/4096.0;
+      prolongation[1](30,46) = -135.0/4096.0;
+      prolongation[1](30,47) = 45.0/4096.0;
+      prolongation[1](30,48) = -135.0/4096.0;
+      prolongation[1](30,49) = -135.0/4096.0;
+      prolongation[1](30,50) = 45.0/4096.0;
+      prolongation[1](30,51) = 45.0/4096.0;
+      prolongation[1](30,52) = -135.0/4096.0;
+      prolongation[1](30,53) = 45.0/4096.0;
+      prolongation[1](30,54) = -135.0/4096.0;
+      prolongation[1](30,55) = 45.0/4096.0;
+      prolongation[1](30,56) = 1215.0/4096.0;
+      prolongation[1](30,57) = 1215.0/4096.0;
+      prolongation[1](30,58) = -405.0/4096.0;
+      prolongation[1](30,59) = -405.0/4096.0;
+      prolongation[1](30,60) = 1215.0/4096.0;
+      prolongation[1](30,61) = 1215.0/4096.0;
+      prolongation[1](30,62) = -405.0/4096.0;
+      prolongation[1](30,63) = -405.0/4096.0;
+      prolongation[1](31,24) = 1.0/256.0;
+      prolongation[1](31,26) = 1.0/256.0;
+      prolongation[1](31,28) = 1.0/256.0;
+      prolongation[1](31,30) = 1.0/256.0;
+      prolongation[1](31,40) = -9.0/256.0;
+      prolongation[1](31,41) = -9.0/256.0;
+      prolongation[1](31,44) = -9.0/256.0;
+      prolongation[1](31,46) = -9.0/256.0;
+      prolongation[1](31,48) = -9.0/256.0;
+      prolongation[1](31,49) = -9.0/256.0;
+      prolongation[1](31,52) = -9.0/256.0;
+      prolongation[1](31,54) = -9.0/256.0;
+      prolongation[1](31,56) = 81.0/256.0;
+      prolongation[1](31,57) = 81.0/256.0;
+      prolongation[1](31,60) = 81.0/256.0;
+      prolongation[1](31,61) = 81.0/256.0;
+      prolongation[1](32,9) = 5.0/16.0;
+      prolongation[1](32,13) = 1.0/16.0;
+      prolongation[1](32,33) = 15.0/16.0;
+      prolongation[1](32,35) = -5.0/16.0;
+      prolongation[1](33,0) = 5.0/256.0;
+      prolongation[1](33,1) = 25.0/256.0;
+      prolongation[1](33,2) = 5.0/256.0;
+      prolongation[1](33,3) = 1.0/256.0;
+      prolongation[1](33,8) = -25.0/256.0;
+      prolongation[1](33,9) = 75.0/256.0;
+      prolongation[1](33,10) = 75.0/256.0;
+      prolongation[1](33,11) = -25.0/256.0;
+      prolongation[1](33,12) = -5.0/256.0;
+      prolongation[1](33,13) = 15.0/256.0;
+      prolongation[1](33,14) = 15.0/256.0;
+      prolongation[1](33,15) = -5.0/256.0;
+      prolongation[1](33,32) = -75.0/256.0;
+      prolongation[1](33,33) = 225.0/256.0;
+      prolongation[1](33,34) = 25.0/256.0;
+      prolongation[1](33,35) = -75.0/256.0;
+      prolongation[1](34,33) = 1.0;
+      prolongation[1](35,10) = 5.0/16.0;
+      prolongation[1](35,14) = 1.0/16.0;
+      prolongation[1](35,32) = -5.0/16.0;
+      prolongation[1](35,33) = 15.0/16.0;
+      prolongation[1](36,9) = -5.0/256.0;
+      prolongation[1](36,13) = -1.0/256.0;
+      prolongation[1](36,17) = -5.0/256.0;
+      prolongation[1](36,21) = -1.0/256.0;
+      prolongation[1](36,33) = -15.0/256.0;
+      prolongation[1](36,35) = 5.0/256.0;
+      prolongation[1](36,37) = -15.0/256.0;
+      prolongation[1](36,39) = 5.0/256.0;
+      prolongation[1](36,41) = 45.0/256.0;
+      prolongation[1](36,43) = 45.0/256.0;
+      prolongation[1](36,49) = 9.0/256.0;
+      prolongation[1](36,51) = 9.0/256.0;
+      prolongation[1](36,57) = 135.0/256.0;
+      prolongation[1](36,59) = 135.0/256.0;
+      prolongation[1](36,61) = -45.0/256.0;
+      prolongation[1](36,63) = -45.0/256.0;
+      prolongation[1](37,0) = -5.0/4096.0;
+      prolongation[1](37,1) = -25.0/4096.0;
+      prolongation[1](37,2) = -5.0/4096.0;
+      prolongation[1](37,3) = -1.0/4096.0;
+      prolongation[1](37,4) = -5.0/4096.0;
+      prolongation[1](37,5) = -25.0/4096.0;
+      prolongation[1](37,6) = -5.0/4096.0;
+      prolongation[1](37,7) = -1.0/4096.0;
+      prolongation[1](37,8) = 25.0/4096.0;
+      prolongation[1](37,9) = -75.0/4096.0;
+      prolongation[1](37,10) = -75.0/4096.0;
+      prolongation[1](37,11) = 25.0/4096.0;
+      prolongation[1](37,12) = 5.0/4096.0;
+      prolongation[1](37,13) = -15.0/4096.0;
+      prolongation[1](37,14) = -15.0/4096.0;
+      prolongation[1](37,15) = 5.0/4096.0;
+      prolongation[1](37,16) = 25.0/4096.0;
+      prolongation[1](37,17) = -75.0/4096.0;
+      prolongation[1](37,18) = -75.0/4096.0;
+      prolongation[1](37,19) = 25.0/4096.0;
+      prolongation[1](37,20) = 5.0/4096.0;
+      prolongation[1](37,21) = -15.0/4096.0;
+      prolongation[1](37,22) = -15.0/4096.0;
+      prolongation[1](37,23) = 5.0/4096.0;
+      prolongation[1](37,24) = 45.0/4096.0;
+      prolongation[1](37,25) = 45.0/4096.0;
+      prolongation[1](37,26) = 225.0/4096.0;
+      prolongation[1](37,27) = 225.0/4096.0;
+      prolongation[1](37,28) = 45.0/4096.0;
+      prolongation[1](37,29) = 45.0/4096.0;
+      prolongation[1](37,30) = 9.0/4096.0;
+      prolongation[1](37,31) = 9.0/4096.0;
+      prolongation[1](37,32) = 75.0/4096.0;
+      prolongation[1](37,33) = -225.0/4096.0;
+      prolongation[1](37,34) = -25.0/4096.0;
+      prolongation[1](37,35) = 75.0/4096.0;
+      prolongation[1](37,36) = 75.0/4096.0;
+      prolongation[1](37,37) = -225.0/4096.0;
+      prolongation[1](37,38) = -25.0/4096.0;
+      prolongation[1](37,39) = 75.0/4096.0;
+      prolongation[1](37,40) = -225.0/4096.0;
+      prolongation[1](37,41) = 675.0/4096.0;
+      prolongation[1](37,42) = -225.0/4096.0;
+      prolongation[1](37,43) = 675.0/4096.0;
+      prolongation[1](37,44) = 675.0/4096.0;
+      prolongation[1](37,45) = 675.0/4096.0;
+      prolongation[1](37,46) = -225.0/4096.0;
+      prolongation[1](37,47) = -225.0/4096.0;
+      prolongation[1](37,48) = -45.0/4096.0;
+      prolongation[1](37,49) = 135.0/4096.0;
+      prolongation[1](37,50) = -45.0/4096.0;
+      prolongation[1](37,51) = 135.0/4096.0;
+      prolongation[1](37,52) = 135.0/4096.0;
+      prolongation[1](37,53) = 135.0/4096.0;
+      prolongation[1](37,54) = -45.0/4096.0;
+      prolongation[1](37,55) = -45.0/4096.0;
+      prolongation[1](37,56) = -675.0/4096.0;
+      prolongation[1](37,57) = 2025.0/4096.0;
+      prolongation[1](37,58) = -675.0/4096.0;
+      prolongation[1](37,59) = 2025.0/4096.0;
+      prolongation[1](37,60) = 225.0/4096.0;
+      prolongation[1](37,61) = -675.0/4096.0;
+      prolongation[1](37,62) = 225.0/4096.0;
+      prolongation[1](37,63) = -675.0/4096.0;
+      prolongation[1](38,33) = -1.0/16.0;
+      prolongation[1](38,37) = -1.0/16.0;
+      prolongation[1](38,57) = 9.0/16.0;
+      prolongation[1](38,59) = 9.0/16.0;
+      prolongation[1](39,10) = -5.0/256.0;
+      prolongation[1](39,14) = -1.0/256.0;
+      prolongation[1](39,18) = -5.0/256.0;
+      prolongation[1](39,22) = -1.0/256.0;
+      prolongation[1](39,32) = 5.0/256.0;
+      prolongation[1](39,33) = -15.0/256.0;
+      prolongation[1](39,36) = 5.0/256.0;
+      prolongation[1](39,37) = -15.0/256.0;
+      prolongation[1](39,44) = 45.0/256.0;
+      prolongation[1](39,45) = 45.0/256.0;
+      prolongation[1](39,52) = 9.0/256.0;
+      prolongation[1](39,53) = 9.0/256.0;
+      prolongation[1](39,56) = -45.0/256.0;
+      prolongation[1](39,57) = 135.0/256.0;
+      prolongation[1](39,58) = -45.0/256.0;
+      prolongation[1](39,59) = 135.0/256.0;
+      prolongation[1](40,9) = 5.0/16.0;
+      prolongation[1](40,17) = 1.0/16.0;
+      prolongation[1](40,41) = 15.0/16.0;
+      prolongation[1](40,43) = -5.0/16.0;
+      prolongation[1](41,0) = 5.0/256.0;
+      prolongation[1](41,1) = 25.0/256.0;
+      prolongation[1](41,4) = 1.0/256.0;
+      prolongation[1](41,5) = 5.0/256.0;
+      prolongation[1](41,8) = -25.0/256.0;
+      prolongation[1](41,9) = 75.0/256.0;
+      prolongation[1](41,16) = -5.0/256.0;
+      prolongation[1](41,17) = 15.0/256.0;
+      prolongation[1](41,24) = 15.0/256.0;
+      prolongation[1](41,25) = -5.0/256.0;
+      prolongation[1](41,26) = 75.0/256.0;
+      prolongation[1](41,27) = -25.0/256.0;
+      prolongation[1](41,40) = -75.0/256.0;
+      prolongation[1](41,41) = 225.0/256.0;
+      prolongation[1](41,42) = 25.0/256.0;
+      prolongation[1](41,43) = -75.0/256.0;
+      prolongation[1](42,41) = 1.0;
+      prolongation[1](43,24) = 1.0/16.0;
+      prolongation[1](43,26) = 5.0/16.0;
+      prolongation[1](43,40) = -5.0/16.0;
+      prolongation[1](43,41) = 15.0/16.0;
+      prolongation[1](44,1) = 25.0/256.0;
+      prolongation[1](44,2) = 5.0/256.0;
+      prolongation[1](44,5) = 5.0/256.0;
+      prolongation[1](44,6) = 1.0/256.0;
+      prolongation[1](44,10) = 75.0/256.0;
+      prolongation[1](44,11) = -25.0/256.0;
+      prolongation[1](44,18) = 15.0/256.0;
+      prolongation[1](44,19) = -5.0/256.0;
+      prolongation[1](44,26) = 75.0/256.0;
+      prolongation[1](44,27) = -25.0/256.0;
+      prolongation[1](44,28) = 15.0/256.0;
+      prolongation[1](44,29) = -5.0/256.0;
+      prolongation[1](44,44) = 225.0/256.0;
+      prolongation[1](44,45) = -75.0/256.0;
+      prolongation[1](44,46) = -75.0/256.0;
+      prolongation[1](44,47) = 25.0/256.0;
+      prolongation[1](45,26) = 5.0/16.0;
+      prolongation[1](45,28) = 1.0/16.0;
+      prolongation[1](45,44) = 15.0/16.0;
+      prolongation[1](45,46) = -5.0/16.0;
+      prolongation[1](46,10) = 5.0/16.0;
+      prolongation[1](46,18) = 1.0/16.0;
+      prolongation[1](46,44) = 15.0/16.0;
+      prolongation[1](46,45) = -5.0/16.0;
+      prolongation[1](47,44) = 1.0;
+      prolongation[1](48,9) = -5.0/256.0;
+      prolongation[1](48,13) = -5.0/256.0;
+      prolongation[1](48,17) = -1.0/256.0;
+      prolongation[1](48,21) = -1.0/256.0;
+      prolongation[1](48,33) = 45.0/256.0;
+      prolongation[1](48,35) = 45.0/256.0;
+      prolongation[1](48,37) = 9.0/256.0;
+      prolongation[1](48,39) = 9.0/256.0;
+      prolongation[1](48,41) = -15.0/256.0;
+      prolongation[1](48,43) = 5.0/256.0;
+      prolongation[1](48,49) = -15.0/256.0;
+      prolongation[1](48,51) = 5.0/256.0;
+      prolongation[1](48,57) = 135.0/256.0;
+      prolongation[1](48,59) = -45.0/256.0;
+      prolongation[1](48,61) = 135.0/256.0;
+      prolongation[1](48,63) = -45.0/256.0;
+      prolongation[1](49,0) = -5.0/4096.0;
+      prolongation[1](49,1) = -25.0/4096.0;
+      prolongation[1](49,2) = -25.0/4096.0;
+      prolongation[1](49,3) = -5.0/4096.0;
+      prolongation[1](49,4) = -1.0/4096.0;
+      prolongation[1](49,5) = -5.0/4096.0;
+      prolongation[1](49,6) = -5.0/4096.0;
+      prolongation[1](49,7) = -1.0/4096.0;
+      prolongation[1](49,8) = 25.0/4096.0;
+      prolongation[1](49,9) = -75.0/4096.0;
+      prolongation[1](49,10) = 225.0/4096.0;
+      prolongation[1](49,11) = 225.0/4096.0;
+      prolongation[1](49,12) = 25.0/4096.0;
+      prolongation[1](49,13) = -75.0/4096.0;
+      prolongation[1](49,14) = 45.0/4096.0;
+      prolongation[1](49,15) = 45.0/4096.0;
+      prolongation[1](49,16) = 5.0/4096.0;
+      prolongation[1](49,17) = -15.0/4096.0;
+      prolongation[1](49,18) = 45.0/4096.0;
+      prolongation[1](49,19) = 45.0/4096.0;
+      prolongation[1](49,20) = 5.0/4096.0;
+      prolongation[1](49,21) = -15.0/4096.0;
+      prolongation[1](49,22) = 9.0/4096.0;
+      prolongation[1](49,23) = 9.0/4096.0;
+      prolongation[1](49,24) = -15.0/4096.0;
+      prolongation[1](49,25) = 5.0/4096.0;
+      prolongation[1](49,26) = -75.0/4096.0;
+      prolongation[1](49,27) = 25.0/4096.0;
+      prolongation[1](49,28) = -75.0/4096.0;
+      prolongation[1](49,29) = 25.0/4096.0;
+      prolongation[1](49,30) = -15.0/4096.0;
+      prolongation[1](49,31) = 5.0/4096.0;
+      prolongation[1](49,32) = -225.0/4096.0;
+      prolongation[1](49,33) = 675.0/4096.0;
+      prolongation[1](49,34) = -225.0/4096.0;
+      prolongation[1](49,35) = 675.0/4096.0;
+      prolongation[1](49,36) = -45.0/4096.0;
+      prolongation[1](49,37) = 135.0/4096.0;
+      prolongation[1](49,38) = -45.0/4096.0;
+      prolongation[1](49,39) = 135.0/4096.0;
+      prolongation[1](49,40) = 75.0/4096.0;
+      prolongation[1](49,41) = -225.0/4096.0;
+      prolongation[1](49,42) = -25.0/4096.0;
+      prolongation[1](49,43) = 75.0/4096.0;
+      prolongation[1](49,44) = 675.0/4096.0;
+      prolongation[1](49,45) = -225.0/4096.0;
+      prolongation[1](49,46) = 675.0/4096.0;
+      prolongation[1](49,47) = -225.0/4096.0;
+      prolongation[1](49,48) = 75.0/4096.0;
+      prolongation[1](49,49) = -225.0/4096.0;
+      prolongation[1](49,50) = -25.0/4096.0;
+      prolongation[1](49,51) = 75.0/4096.0;
+      prolongation[1](49,52) = 135.0/4096.0;
+      prolongation[1](49,53) = -45.0/4096.0;
+      prolongation[1](49,54) = 135.0/4096.0;
+      prolongation[1](49,55) = -45.0/4096.0;
+      prolongation[1](49,56) = -675.0/4096.0;
+      prolongation[1](49,57) = 2025.0/4096.0;
+      prolongation[1](49,58) = 225.0/4096.0;
+      prolongation[1](49,59) = -675.0/4096.0;
+      prolongation[1](49,60) = -675.0/4096.0;
+      prolongation[1](49,61) = 2025.0/4096.0;
+      prolongation[1](49,62) = 225.0/4096.0;
+      prolongation[1](49,63) = -675.0/4096.0;
+      prolongation[1](50,41) = -1.0/16.0;
+      prolongation[1](50,49) = -1.0/16.0;
+      prolongation[1](50,57) = 9.0/16.0;
+      prolongation[1](50,61) = 9.0/16.0;
+      prolongation[1](51,24) = -1.0/256.0;
+      prolongation[1](51,26) = -5.0/256.0;
+      prolongation[1](51,28) = -5.0/256.0;
+      prolongation[1](51,30) = -1.0/256.0;
+      prolongation[1](51,40) = 5.0/256.0;
+      prolongation[1](51,41) = -15.0/256.0;
+      prolongation[1](51,44) = 45.0/256.0;
+      prolongation[1](51,46) = 45.0/256.0;
+      prolongation[1](51,48) = 5.0/256.0;
+      prolongation[1](51,49) = -15.0/256.0;
+      prolongation[1](51,52) = 9.0/256.0;
+      prolongation[1](51,54) = 9.0/256.0;
+      prolongation[1](51,56) = -45.0/256.0;
+      prolongation[1](51,57) = 135.0/256.0;
+      prolongation[1](51,60) = -45.0/256.0;
+      prolongation[1](51,61) = 135.0/256.0;
+      prolongation[1](52,0) = -25.0/4096.0;
+      prolongation[1](52,1) = -25.0/4096.0;
+      prolongation[1](52,2) = -5.0/4096.0;
+      prolongation[1](52,3) = -5.0/4096.0;
+      prolongation[1](52,4) = -5.0/4096.0;
+      prolongation[1](52,5) = -5.0/4096.0;
+      prolongation[1](52,6) = -1.0/4096.0;
+      prolongation[1](52,7) = -1.0/4096.0;
+      prolongation[1](52,8) = 225.0/4096.0;
+      prolongation[1](52,9) = 225.0/4096.0;
+      prolongation[1](52,10) = -75.0/4096.0;
+      prolongation[1](52,11) = 25.0/4096.0;
+      prolongation[1](52,12) = 45.0/4096.0;
+      prolongation[1](52,13) = 45.0/4096.0;
+      prolongation[1](52,14) = -75.0/4096.0;
+      prolongation[1](52,15) = 25.0/4096.0;
+      prolongation[1](52,16) = 45.0/4096.0;
+      prolongation[1](52,17) = 45.0/4096.0;
+      prolongation[1](52,18) = -15.0/4096.0;
+      prolongation[1](52,19) = 5.0/4096.0;
+      prolongation[1](52,20) = 9.0/4096.0;
+      prolongation[1](52,21) = 9.0/4096.0;
+      prolongation[1](52,22) = -15.0/4096.0;
+      prolongation[1](52,23) = 5.0/4096.0;
+      prolongation[1](52,24) = -75.0/4096.0;
+      prolongation[1](52,25) = 25.0/4096.0;
+      prolongation[1](52,26) = -75.0/4096.0;
+      prolongation[1](52,27) = 25.0/4096.0;
+      prolongation[1](52,28) = -15.0/4096.0;
+      prolongation[1](52,29) = 5.0/4096.0;
+      prolongation[1](52,30) = -15.0/4096.0;
+      prolongation[1](52,31) = 5.0/4096.0;
+      prolongation[1](52,32) = 675.0/4096.0;
+      prolongation[1](52,33) = 675.0/4096.0;
+      prolongation[1](52,34) = -225.0/4096.0;
+      prolongation[1](52,35) = -225.0/4096.0;
+      prolongation[1](52,36) = 135.0/4096.0;
+      prolongation[1](52,37) = 135.0/4096.0;
+      prolongation[1](52,38) = -45.0/4096.0;
+      prolongation[1](52,39) = -45.0/4096.0;
+      prolongation[1](52,40) = 675.0/4096.0;
+      prolongation[1](52,41) = 675.0/4096.0;
+      prolongation[1](52,42) = -225.0/4096.0;
+      prolongation[1](52,43) = -225.0/4096.0;
+      prolongation[1](52,44) = -225.0/4096.0;
+      prolongation[1](52,45) = 75.0/4096.0;
+      prolongation[1](52,46) = 75.0/4096.0;
+      prolongation[1](52,47) = -25.0/4096.0;
+      prolongation[1](52,48) = 135.0/4096.0;
+      prolongation[1](52,49) = 135.0/4096.0;
+      prolongation[1](52,50) = -45.0/4096.0;
+      prolongation[1](52,51) = -45.0/4096.0;
+      prolongation[1](52,52) = -225.0/4096.0;
+      prolongation[1](52,53) = 75.0/4096.0;
+      prolongation[1](52,54) = 75.0/4096.0;
+      prolongation[1](52,55) = -25.0/4096.0;
+      prolongation[1](52,56) = 2025.0/4096.0;
+      prolongation[1](52,57) = 2025.0/4096.0;
+      prolongation[1](52,58) = -675.0/4096.0;
+      prolongation[1](52,59) = -675.0/4096.0;
+      prolongation[1](52,60) = -675.0/4096.0;
+      prolongation[1](52,61) = -675.0/4096.0;
+      prolongation[1](52,62) = 225.0/4096.0;
+      prolongation[1](52,63) = 225.0/4096.0;
+      prolongation[1](53,24) = -5.0/256.0;
+      prolongation[1](53,26) = -5.0/256.0;
+      prolongation[1](53,28) = -1.0/256.0;
+      prolongation[1](53,30) = -1.0/256.0;
+      prolongation[1](53,40) = 45.0/256.0;
+      prolongation[1](53,41) = 45.0/256.0;
+      prolongation[1](53,44) = -15.0/256.0;
+      prolongation[1](53,46) = 5.0/256.0;
+      prolongation[1](53,48) = 9.0/256.0;
+      prolongation[1](53,49) = 9.0/256.0;
+      prolongation[1](53,52) = -15.0/256.0;
+      prolongation[1](53,54) = 5.0/256.0;
+      prolongation[1](53,56) = 135.0/256.0;
+      prolongation[1](53,57) = 135.0/256.0;
+      prolongation[1](53,60) = -45.0/256.0;
+      prolongation[1](53,61) = -45.0/256.0;
+      prolongation[1](54,10) = -5.0/256.0;
+      prolongation[1](54,14) = -5.0/256.0;
+      prolongation[1](54,18) = -1.0/256.0;
+      prolongation[1](54,22) = -1.0/256.0;
+      prolongation[1](54,32) = 45.0/256.0;
+      prolongation[1](54,33) = 45.0/256.0;
+      prolongation[1](54,36) = 9.0/256.0;
+      prolongation[1](54,37) = 9.0/256.0;
+      prolongation[1](54,44) = -15.0/256.0;
+      prolongation[1](54,45) = 5.0/256.0;
+      prolongation[1](54,52) = -15.0/256.0;
+      prolongation[1](54,53) = 5.0/256.0;
+      prolongation[1](54,56) = 135.0/256.0;
+      prolongation[1](54,57) = 135.0/256.0;
+      prolongation[1](54,58) = -45.0/256.0;
+      prolongation[1](54,59) = -45.0/256.0;
+      prolongation[1](55,44) = -1.0/16.0;
+      prolongation[1](55,52) = -1.0/16.0;
+      prolongation[1](55,56) = 9.0/16.0;
+      prolongation[1](55,57) = 9.0/16.0;
+      prolongation[1](56,9) = 25.0/256.0;
+      prolongation[1](56,13) = 5.0/256.0;
+      prolongation[1](56,17) = 5.0/256.0;
+      prolongation[1](56,21) = 1.0/256.0;
+      prolongation[1](56,33) = 75.0/256.0;
+      prolongation[1](56,35) = -25.0/256.0;
+      prolongation[1](56,37) = 15.0/256.0;
+      prolongation[1](56,39) = -5.0/256.0;
+      prolongation[1](56,41) = 75.0/256.0;
+      prolongation[1](56,43) = -25.0/256.0;
+      prolongation[1](56,49) = 15.0/256.0;
+      prolongation[1](56,51) = -5.0/256.0;
+      prolongation[1](56,57) = 225.0/256.0;
+      prolongation[1](56,59) = -75.0/256.0;
+      prolongation[1](56,61) = -75.0/256.0;
+      prolongation[1](56,63) = 25.0/256.0;
+      prolongation[1](57,0) = 25.0/4096.0;
+      prolongation[1](57,1) = 125.0/4096.0;
+      prolongation[1](57,2) = 25.0/4096.0;
+      prolongation[1](57,3) = 5.0/4096.0;
+      prolongation[1](57,4) = 5.0/4096.0;
+      prolongation[1](57,5) = 25.0/4096.0;
+      prolongation[1](57,6) = 5.0/4096.0;
+      prolongation[1](57,7) = 1.0/4096.0;
+      prolongation[1](57,8) = -125.0/4096.0;
+      prolongation[1](57,9) = 375.0/4096.0;
+      prolongation[1](57,10) = 375.0/4096.0;
+      prolongation[1](57,11) = -125.0/4096.0;
+      prolongation[1](57,12) = -25.0/4096.0;
+      prolongation[1](57,13) = 75.0/4096.0;
+      prolongation[1](57,14) = 75.0/4096.0;
+      prolongation[1](57,15) = -25.0/4096.0;
+      prolongation[1](57,16) = -25.0/4096.0;
+      prolongation[1](57,17) = 75.0/4096.0;
+      prolongation[1](57,18) = 75.0/4096.0;
+      prolongation[1](57,19) = -25.0/4096.0;
+      prolongation[1](57,20) = -5.0/4096.0;
+      prolongation[1](57,21) = 15.0/4096.0;
+      prolongation[1](57,22) = 15.0/4096.0;
+      prolongation[1](57,23) = -5.0/4096.0;
+      prolongation[1](57,24) = 75.0/4096.0;
+      prolongation[1](57,25) = -25.0/4096.0;
+      prolongation[1](57,26) = 375.0/4096.0;
+      prolongation[1](57,27) = -125.0/4096.0;
+      prolongation[1](57,28) = 75.0/4096.0;
+      prolongation[1](57,29) = -25.0/4096.0;
+      prolongation[1](57,30) = 15.0/4096.0;
+      prolongation[1](57,31) = -5.0/4096.0;
+      prolongation[1](57,32) = -375.0/4096.0;
+      prolongation[1](57,33) = 1125.0/4096.0;
+      prolongation[1](57,34) = 125.0/4096.0;
+      prolongation[1](57,35) = -375.0/4096.0;
+      prolongation[1](57,36) = -75.0/4096.0;
+      prolongation[1](57,37) = 225.0/4096.0;
+      prolongation[1](57,38) = 25.0/4096.0;
+      prolongation[1](57,39) = -75.0/4096.0;
+      prolongation[1](57,40) = -375.0/4096.0;
+      prolongation[1](57,41) = 1125.0/4096.0;
+      prolongation[1](57,42) = 125.0/4096.0;
+      prolongation[1](57,43) = -375.0/4096.0;
+      prolongation[1](57,44) = 1125.0/4096.0;
+      prolongation[1](57,45) = -375.0/4096.0;
+      prolongation[1](57,46) = -375.0/4096.0;
+      prolongation[1](57,47) = 125.0/4096.0;
+      prolongation[1](57,48) = -75.0/4096.0;
+      prolongation[1](57,49) = 225.0/4096.0;
+      prolongation[1](57,50) = 25.0/4096.0;
+      prolongation[1](57,51) = -75.0/4096.0;
+      prolongation[1](57,52) = 225.0/4096.0;
+      prolongation[1](57,53) = -75.0/4096.0;
+      prolongation[1](57,54) = -75.0/4096.0;
+      prolongation[1](57,55) = 25.0/4096.0;
+      prolongation[1](57,56) = -1125.0/4096.0;
+      prolongation[1](57,57) = 3375.0/4096.0;
+      prolongation[1](57,58) = 375.0/4096.0;
+      prolongation[1](57,59) = -1125.0/4096.0;
+      prolongation[1](57,60) = 375.0/4096.0;
+      prolongation[1](57,61) = -1125.0/4096.0;
+      prolongation[1](57,62) = -125.0/4096.0;
+      prolongation[1](57,63) = 375.0/4096.0;
+      prolongation[1](58,41) = 5.0/16.0;
+      prolongation[1](58,49) = 1.0/16.0;
+      prolongation[1](58,57) = 15.0/16.0;
+      prolongation[1](58,61) = -5.0/16.0;
+      prolongation[1](59,24) = 5.0/256.0;
+      prolongation[1](59,26) = 25.0/256.0;
+      prolongation[1](59,28) = 5.0/256.0;
+      prolongation[1](59,30) = 1.0/256.0;
+      prolongation[1](59,40) = -25.0/256.0;
+      prolongation[1](59,41) = 75.0/256.0;
+      prolongation[1](59,44) = 75.0/256.0;
+      prolongation[1](59,46) = -25.0/256.0;
+      prolongation[1](59,48) = -5.0/256.0;
+      prolongation[1](59,49) = 15.0/256.0;
+      prolongation[1](59,52) = 15.0/256.0;
+      prolongation[1](59,54) = -5.0/256.0;
+      prolongation[1](59,56) = -75.0/256.0;
+      prolongation[1](59,57) = 225.0/256.0;
+      prolongation[1](59,60) = 25.0/256.0;
+      prolongation[1](59,61) = -75.0/256.0;
+      prolongation[1](60,33) = 5.0/16.0;
+      prolongation[1](60,37) = 1.0/16.0;
+      prolongation[1](60,57) = 15.0/16.0;
+      prolongation[1](60,59) = -5.0/16.0;
+      prolongation[1](61,10) = 25.0/256.0;
+      prolongation[1](61,14) = 5.0/256.0;
+      prolongation[1](61,18) = 5.0/256.0;
+      prolongation[1](61,22) = 1.0/256.0;
+      prolongation[1](61,32) = -25.0/256.0;
+      prolongation[1](61,33) = 75.0/256.0;
+      prolongation[1](61,36) = -5.0/256.0;
+      prolongation[1](61,37) = 15.0/256.0;
+      prolongation[1](61,44) = 75.0/256.0;
+      prolongation[1](61,45) = -25.0/256.0;
+      prolongation[1](61,52) = 15.0/256.0;
+      prolongation[1](61,53) = -5.0/256.0;
+      prolongation[1](61,56) = -75.0/256.0;
+      prolongation[1](61,57) = 225.0/256.0;
+      prolongation[1](61,58) = 25.0/256.0;
+      prolongation[1](61,59) = -75.0/256.0;
+      prolongation[1](62,57) = 1.0;
+      prolongation[1](63,44) = 5.0/16.0;
+      prolongation[1](63,52) = 1.0/16.0;
+      prolongation[1](63,56) = -5.0/16.0;
+      prolongation[1](63,57) = 15.0/16.0;
+      prolongation[2](0,0) = 1.0/256.0;
+      prolongation[2](0,1) = 1.0/256.0;
+      prolongation[2](0,2) = 1.0/256.0;
+      prolongation[2](0,3) = 1.0/256.0;
+      prolongation[2](0,8) = -9.0/256.0;
+      prolongation[2](0,9) = -9.0/256.0;
+      prolongation[2](0,10) = -9.0/256.0;
+      prolongation[2](0,11) = -9.0/256.0;
+      prolongation[2](0,12) = -9.0/256.0;
+      prolongation[2](0,13) = -9.0/256.0;
+      prolongation[2](0,14) = -9.0/256.0;
+      prolongation[2](0,15) = -9.0/256.0;
+      prolongation[2](0,32) = 81.0/256.0;
+      prolongation[2](0,33) = 81.0/256.0;
+      prolongation[2](0,34) = 81.0/256.0;
+      prolongation[2](0,35) = 81.0/256.0;
+      prolongation[2](1,1) = -1.0/16.0;
+      prolongation[2](1,2) = -1.0/16.0;
+      prolongation[2](1,10) = 9.0/16.0;
+      prolongation[2](1,11) = 9.0/16.0;
+      prolongation[2](2,2) = 1.0;
+      prolongation[2](3,2) = -1.0/16.0;
+      prolongation[2](3,3) = -1.0/16.0;
+      prolongation[2](3,12) = 9.0/16.0;
+      prolongation[2](3,13) = 9.0/16.0;
+      prolongation[2](4,0) = -1.0/4096.0;
+      prolongation[2](4,1) = -1.0/4096.0;
+      prolongation[2](4,2) = -1.0/4096.0;
+      prolongation[2](4,3) = -1.0/4096.0;
+      prolongation[2](4,4) = -1.0/4096.0;
+      prolongation[2](4,5) = -1.0/4096.0;
+      prolongation[2](4,6) = -1.0/4096.0;
+      prolongation[2](4,7) = -1.0/4096.0;
+      prolongation[2](4,8) = 9.0/4096.0;
+      prolongation[2](4,9) = 9.0/4096.0;
+      prolongation[2](4,10) = 9.0/4096.0;
+      prolongation[2](4,11) = 9.0/4096.0;
+      prolongation[2](4,12) = 9.0/4096.0;
+      prolongation[2](4,13) = 9.0/4096.0;
+      prolongation[2](4,14) = 9.0/4096.0;
+      prolongation[2](4,15) = 9.0/4096.0;
+      prolongation[2](4,16) = 9.0/4096.0;
+      prolongation[2](4,17) = 9.0/4096.0;
+      prolongation[2](4,18) = 9.0/4096.0;
+      prolongation[2](4,19) = 9.0/4096.0;
+      prolongation[2](4,20) = 9.0/4096.0;
+      prolongation[2](4,21) = 9.0/4096.0;
+      prolongation[2](4,22) = 9.0/4096.0;
+      prolongation[2](4,23) = 9.0/4096.0;
+      prolongation[2](4,24) = 9.0/4096.0;
+      prolongation[2](4,25) = 9.0/4096.0;
+      prolongation[2](4,26) = 9.0/4096.0;
+      prolongation[2](4,27) = 9.0/4096.0;
+      prolongation[2](4,28) = 9.0/4096.0;
+      prolongation[2](4,29) = 9.0/4096.0;
+      prolongation[2](4,30) = 9.0/4096.0;
+      prolongation[2](4,31) = 9.0/4096.0;
+      prolongation[2](4,32) = -81.0/4096.0;
+      prolongation[2](4,33) = -81.0/4096.0;
+      prolongation[2](4,34) = -81.0/4096.0;
+      prolongation[2](4,35) = -81.0/4096.0;
+      prolongation[2](4,36) = -81.0/4096.0;
+      prolongation[2](4,37) = -81.0/4096.0;
+      prolongation[2](4,38) = -81.0/4096.0;
+      prolongation[2](4,39) = -81.0/4096.0;
+      prolongation[2](4,40) = -81.0/4096.0;
+      prolongation[2](4,41) = -81.0/4096.0;
+      prolongation[2](4,42) = -81.0/4096.0;
+      prolongation[2](4,43) = -81.0/4096.0;
+      prolongation[2](4,44) = -81.0/4096.0;
+      prolongation[2](4,45) = -81.0/4096.0;
+      prolongation[2](4,46) = -81.0/4096.0;
+      prolongation[2](4,47) = -81.0/4096.0;
+      prolongation[2](4,48) = -81.0/4096.0;
+      prolongation[2](4,49) = -81.0/4096.0;
+      prolongation[2](4,50) = -81.0/4096.0;
+      prolongation[2](4,51) = -81.0/4096.0;
+      prolongation[2](4,52) = -81.0/4096.0;
+      prolongation[2](4,53) = -81.0/4096.0;
+      prolongation[2](4,54) = -81.0/4096.0;
+      prolongation[2](4,55) = -81.0/4096.0;
+      prolongation[2](4,56) = 729.0/4096.0;
+      prolongation[2](4,57) = 729.0/4096.0;
+      prolongation[2](4,58) = 729.0/4096.0;
+      prolongation[2](4,59) = 729.0/4096.0;
+      prolongation[2](4,60) = 729.0/4096.0;
+      prolongation[2](4,61) = 729.0/4096.0;
+      prolongation[2](4,62) = 729.0/4096.0;
+      prolongation[2](4,63) = 729.0/4096.0;
+      prolongation[2](5,1) = 1.0/256.0;
+      prolongation[2](5,2) = 1.0/256.0;
+      prolongation[2](5,5) = 1.0/256.0;
+      prolongation[2](5,6) = 1.0/256.0;
+      prolongation[2](5,10) = -9.0/256.0;
+      prolongation[2](5,11) = -9.0/256.0;
+      prolongation[2](5,18) = -9.0/256.0;
+      prolongation[2](5,19) = -9.0/256.0;
+      prolongation[2](5,26) = -9.0/256.0;
+      prolongation[2](5,27) = -9.0/256.0;
+      prolongation[2](5,28) = -9.0/256.0;
+      prolongation[2](5,29) = -9.0/256.0;
+      prolongation[2](5,44) = 81.0/256.0;
+      prolongation[2](5,45) = 81.0/256.0;
+      prolongation[2](5,46) = 81.0/256.0;
+      prolongation[2](5,47) = 81.0/256.0;
+      prolongation[2](6,2) = -1.0/16.0;
+      prolongation[2](6,6) = -1.0/16.0;
+      prolongation[2](6,28) = 9.0/16.0;
+      prolongation[2](6,29) = 9.0/16.0;
+      prolongation[2](7,2) = 1.0/256.0;
+      prolongation[2](7,3) = 1.0/256.0;
+      prolongation[2](7,6) = 1.0/256.0;
+      prolongation[2](7,7) = 1.0/256.0;
+      prolongation[2](7,12) = -9.0/256.0;
+      prolongation[2](7,13) = -9.0/256.0;
+      prolongation[2](7,20) = -9.0/256.0;
+      prolongation[2](7,21) = -9.0/256.0;
+      prolongation[2](7,28) = -9.0/256.0;
+      prolongation[2](7,29) = -9.0/256.0;
+      prolongation[2](7,30) = -9.0/256.0;
+      prolongation[2](7,31) = -9.0/256.0;
+      prolongation[2](7,48) = 81.0/256.0;
+      prolongation[2](7,49) = 81.0/256.0;
+      prolongation[2](7,50) = 81.0/256.0;
+      prolongation[2](7,51) = 81.0/256.0;
+      prolongation[2](8,9) = -1.0/16.0;
+      prolongation[2](8,13) = -1.0/16.0;
+      prolongation[2](8,33) = 9.0/16.0;
+      prolongation[2](8,35) = 9.0/16.0;
+      prolongation[2](9,0) = -1.0/256.0;
+      prolongation[2](9,1) = -5.0/256.0;
+      prolongation[2](9,2) = -5.0/256.0;
+      prolongation[2](9,3) = -1.0/256.0;
+      prolongation[2](9,8) = 5.0/256.0;
+      prolongation[2](9,9) = -15.0/256.0;
+      prolongation[2](9,10) = 45.0/256.0;
+      prolongation[2](9,11) = 45.0/256.0;
+      prolongation[2](9,12) = 5.0/256.0;
+      prolongation[2](9,13) = -15.0/256.0;
+      prolongation[2](9,14) = 9.0/256.0;
+      prolongation[2](9,15) = 9.0/256.0;
+      prolongation[2](9,32) = -45.0/256.0;
+      prolongation[2](9,33) = 135.0/256.0;
+      prolongation[2](9,34) = -45.0/256.0;
+      prolongation[2](9,35) = 135.0/256.0;
+      prolongation[2](10,11) = 1.0;
+      prolongation[2](11,1) = 1.0/16.0;
+      prolongation[2](11,2) = 5.0/16.0;
+      prolongation[2](11,10) = -5.0/16.0;
+      prolongation[2](11,11) = 15.0/16.0;
+      prolongation[2](12,13) = 1.0;
+      prolongation[2](13,2) = 5.0/16.0;
+      prolongation[2](13,3) = 1.0/16.0;
+      prolongation[2](13,12) = -5.0/16.0;
+      prolongation[2](13,13) = 15.0/16.0;
+      prolongation[2](14,11) = -1.0/16.0;
+      prolongation[2](14,15) = -1.0/16.0;
+      prolongation[2](14,34) = 9.0/16.0;
+      prolongation[2](14,35) = 9.0/16.0;
+      prolongation[2](15,0) = -1.0/256.0;
+      prolongation[2](15,1) = -1.0/256.0;
+      prolongation[2](15,2) = -5.0/256.0;
+      prolongation[2](15,3) = -5.0/256.0;
+      prolongation[2](15,8) = 9.0/256.0;
+      prolongation[2](15,9) = 9.0/256.0;
+      prolongation[2](15,10) = 5.0/256.0;
+      prolongation[2](15,11) = -15.0/256.0;
+      prolongation[2](15,12) = 45.0/256.0;
+      prolongation[2](15,13) = 45.0/256.0;
+      prolongation[2](15,14) = 5.0/256.0;
+      prolongation[2](15,15) = -15.0/256.0;
+      prolongation[2](15,32) = -45.0/256.0;
+      prolongation[2](15,33) = -45.0/256.0;
+      prolongation[2](15,34) = 135.0/256.0;
+      prolongation[2](15,35) = 135.0/256.0;
+      prolongation[2](16,9) = 1.0/256.0;
+      prolongation[2](16,13) = 1.0/256.0;
+      prolongation[2](16,17) = 1.0/256.0;
+      prolongation[2](16,21) = 1.0/256.0;
+      prolongation[2](16,33) = -9.0/256.0;
+      prolongation[2](16,35) = -9.0/256.0;
+      prolongation[2](16,37) = -9.0/256.0;
+      prolongation[2](16,39) = -9.0/256.0;
+      prolongation[2](16,41) = -9.0/256.0;
+      prolongation[2](16,43) = -9.0/256.0;
+      prolongation[2](16,49) = -9.0/256.0;
+      prolongation[2](16,51) = -9.0/256.0;
+      prolongation[2](16,57) = 81.0/256.0;
+      prolongation[2](16,59) = 81.0/256.0;
+      prolongation[2](16,61) = 81.0/256.0;
+      prolongation[2](16,63) = 81.0/256.0;
+      prolongation[2](17,0) = 1.0/4096.0;
+      prolongation[2](17,1) = 5.0/4096.0;
+      prolongation[2](17,2) = 5.0/4096.0;
+      prolongation[2](17,3) = 1.0/4096.0;
+      prolongation[2](17,4) = 1.0/4096.0;
+      prolongation[2](17,5) = 5.0/4096.0;
+      prolongation[2](17,6) = 5.0/4096.0;
+      prolongation[2](17,7) = 1.0/4096.0;
+      prolongation[2](17,8) = -5.0/4096.0;
+      prolongation[2](17,9) = 15.0/4096.0;
+      prolongation[2](17,10) = -45.0/4096.0;
+      prolongation[2](17,11) = -45.0/4096.0;
+      prolongation[2](17,12) = -5.0/4096.0;
+      prolongation[2](17,13) = 15.0/4096.0;
+      prolongation[2](17,14) = -9.0/4096.0;
+      prolongation[2](17,15) = -9.0/4096.0;
+      prolongation[2](17,16) = -5.0/4096.0;
+      prolongation[2](17,17) = 15.0/4096.0;
+      prolongation[2](17,18) = -45.0/4096.0;
+      prolongation[2](17,19) = -45.0/4096.0;
+      prolongation[2](17,20) = -5.0/4096.0;
+      prolongation[2](17,21) = 15.0/4096.0;
+      prolongation[2](17,22) = -9.0/4096.0;
+      prolongation[2](17,23) = -9.0/4096.0;
+      prolongation[2](17,24) = -9.0/4096.0;
+      prolongation[2](17,25) = -9.0/4096.0;
+      prolongation[2](17,26) = -45.0/4096.0;
+      prolongation[2](17,27) = -45.0/4096.0;
+      prolongation[2](17,28) = -45.0/4096.0;
+      prolongation[2](17,29) = -45.0/4096.0;
+      prolongation[2](17,30) = -9.0/4096.0;
+      prolongation[2](17,31) = -9.0/4096.0;
+      prolongation[2](17,32) = 45.0/4096.0;
+      prolongation[2](17,33) = -135.0/4096.0;
+      prolongation[2](17,34) = 45.0/4096.0;
+      prolongation[2](17,35) = -135.0/4096.0;
+      prolongation[2](17,36) = 45.0/4096.0;
+      prolongation[2](17,37) = -135.0/4096.0;
+      prolongation[2](17,38) = 45.0/4096.0;
+      prolongation[2](17,39) = -135.0/4096.0;
+      prolongation[2](17,40) = 45.0/4096.0;
+      prolongation[2](17,41) = -135.0/4096.0;
+      prolongation[2](17,42) = 45.0/4096.0;
+      prolongation[2](17,43) = -135.0/4096.0;
+      prolongation[2](17,44) = 405.0/4096.0;
+      prolongation[2](17,45) = 405.0/4096.0;
+      prolongation[2](17,46) = 405.0/4096.0;
+      prolongation[2](17,47) = 405.0/4096.0;
+      prolongation[2](17,48) = 45.0/4096.0;
+      prolongation[2](17,49) = -135.0/4096.0;
+      prolongation[2](17,50) = 45.0/4096.0;
+      prolongation[2](17,51) = -135.0/4096.0;
+      prolongation[2](17,52) = 81.0/4096.0;
+      prolongation[2](17,53) = 81.0/4096.0;
+      prolongation[2](17,54) = 81.0/4096.0;
+      prolongation[2](17,55) = 81.0/4096.0;
+      prolongation[2](17,56) = -405.0/4096.0;
+      prolongation[2](17,57) = 1215.0/4096.0;
+      prolongation[2](17,58) = -405.0/4096.0;
+      prolongation[2](17,59) = 1215.0/4096.0;
+      prolongation[2](17,60) = -405.0/4096.0;
+      prolongation[2](17,61) = 1215.0/4096.0;
+      prolongation[2](17,62) = -405.0/4096.0;
+      prolongation[2](17,63) = 1215.0/4096.0;
+      prolongation[2](18,11) = -1.0/16.0;
+      prolongation[2](18,19) = -1.0/16.0;
+      prolongation[2](18,46) = 9.0/16.0;
+      prolongation[2](18,47) = 9.0/16.0;
+      prolongation[2](19,1) = -1.0/256.0;
+      prolongation[2](19,2) = -5.0/256.0;
+      prolongation[2](19,5) = -1.0/256.0;
+      prolongation[2](19,6) = -5.0/256.0;
+      prolongation[2](19,10) = 5.0/256.0;
+      prolongation[2](19,11) = -15.0/256.0;
+      prolongation[2](19,18) = 5.0/256.0;
+      prolongation[2](19,19) = -15.0/256.0;
+      prolongation[2](19,26) = 9.0/256.0;
+      prolongation[2](19,27) = 9.0/256.0;
+      prolongation[2](19,28) = 45.0/256.0;
+      prolongation[2](19,29) = 45.0/256.0;
+      prolongation[2](19,44) = -45.0/256.0;
+      prolongation[2](19,45) = -45.0/256.0;
+      prolongation[2](19,46) = 135.0/256.0;
+      prolongation[2](19,47) = 135.0/256.0;
+      prolongation[2](20,13) = -1.0/16.0;
+      prolongation[2](20,21) = -1.0/16.0;
+      prolongation[2](20,49) = 9.0/16.0;
+      prolongation[2](20,51) = 9.0/16.0;
+      prolongation[2](21,2) = -5.0/256.0;
+      prolongation[2](21,3) = -1.0/256.0;
+      prolongation[2](21,6) = -5.0/256.0;
+      prolongation[2](21,7) = -1.0/256.0;
+      prolongation[2](21,12) = 5.0/256.0;
+      prolongation[2](21,13) = -15.0/256.0;
+      prolongation[2](21,20) = 5.0/256.0;
+      prolongation[2](21,21) = -15.0/256.0;
+      prolongation[2](21,28) = 45.0/256.0;
+      prolongation[2](21,29) = 45.0/256.0;
+      prolongation[2](21,30) = 9.0/256.0;
+      prolongation[2](21,31) = 9.0/256.0;
+      prolongation[2](21,48) = -45.0/256.0;
+      prolongation[2](21,49) = 135.0/256.0;
+      prolongation[2](21,50) = -45.0/256.0;
+      prolongation[2](21,51) = 135.0/256.0;
+      prolongation[2](22,11) = 1.0/256.0;
+      prolongation[2](22,15) = 1.0/256.0;
+      prolongation[2](22,19) = 1.0/256.0;
+      prolongation[2](22,23) = 1.0/256.0;
+      prolongation[2](22,34) = -9.0/256.0;
+      prolongation[2](22,35) = -9.0/256.0;
+      prolongation[2](22,38) = -9.0/256.0;
+      prolongation[2](22,39) = -9.0/256.0;
+      prolongation[2](22,46) = -9.0/256.0;
+      prolongation[2](22,47) = -9.0/256.0;
+      prolongation[2](22,54) = -9.0/256.0;
+      prolongation[2](22,55) = -9.0/256.0;
+      prolongation[2](22,60) = 81.0/256.0;
+      prolongation[2](22,61) = 81.0/256.0;
+      prolongation[2](22,62) = 81.0/256.0;
+      prolongation[2](22,63) = 81.0/256.0;
+      prolongation[2](23,0) = 1.0/4096.0;
+      prolongation[2](23,1) = 1.0/4096.0;
+      prolongation[2](23,2) = 5.0/4096.0;
+      prolongation[2](23,3) = 5.0/4096.0;
+      prolongation[2](23,4) = 1.0/4096.0;
+      prolongation[2](23,5) = 1.0/4096.0;
+      prolongation[2](23,6) = 5.0/4096.0;
+      prolongation[2](23,7) = 5.0/4096.0;
+      prolongation[2](23,8) = -9.0/4096.0;
+      prolongation[2](23,9) = -9.0/4096.0;
+      prolongation[2](23,10) = -5.0/4096.0;
+      prolongation[2](23,11) = 15.0/4096.0;
+      prolongation[2](23,12) = -45.0/4096.0;
+      prolongation[2](23,13) = -45.0/4096.0;
+      prolongation[2](23,14) = -5.0/4096.0;
+      prolongation[2](23,15) = 15.0/4096.0;
+      prolongation[2](23,16) = -9.0/4096.0;
+      prolongation[2](23,17) = -9.0/4096.0;
+      prolongation[2](23,18) = -5.0/4096.0;
+      prolongation[2](23,19) = 15.0/4096.0;
+      prolongation[2](23,20) = -45.0/4096.0;
+      prolongation[2](23,21) = -45.0/4096.0;
+      prolongation[2](23,22) = -5.0/4096.0;
+      prolongation[2](23,23) = 15.0/4096.0;
+      prolongation[2](23,24) = -9.0/4096.0;
+      prolongation[2](23,25) = -9.0/4096.0;
+      prolongation[2](23,26) = -9.0/4096.0;
+      prolongation[2](23,27) = -9.0/4096.0;
+      prolongation[2](23,28) = -45.0/4096.0;
+      prolongation[2](23,29) = -45.0/4096.0;
+      prolongation[2](23,30) = -45.0/4096.0;
+      prolongation[2](23,31) = -45.0/4096.0;
+      prolongation[2](23,32) = 45.0/4096.0;
+      prolongation[2](23,33) = 45.0/4096.0;
+      prolongation[2](23,34) = -135.0/4096.0;
+      prolongation[2](23,35) = -135.0/4096.0;
+      prolongation[2](23,36) = 45.0/4096.0;
+      prolongation[2](23,37) = 45.0/4096.0;
+      prolongation[2](23,38) = -135.0/4096.0;
+      prolongation[2](23,39) = -135.0/4096.0;
+      prolongation[2](23,40) = 81.0/4096.0;
+      prolongation[2](23,41) = 81.0/4096.0;
+      prolongation[2](23,42) = 81.0/4096.0;
+      prolongation[2](23,43) = 81.0/4096.0;
+      prolongation[2](23,44) = 45.0/4096.0;
+      prolongation[2](23,45) = 45.0/4096.0;
+      prolongation[2](23,46) = -135.0/4096.0;
+      prolongation[2](23,47) = -135.0/4096.0;
+      prolongation[2](23,48) = 405.0/4096.0;
+      prolongation[2](23,49) = 405.0/4096.0;
+      prolongation[2](23,50) = 405.0/4096.0;
+      prolongation[2](23,51) = 405.0/4096.0;
+      prolongation[2](23,52) = 45.0/4096.0;
+      prolongation[2](23,53) = 45.0/4096.0;
+      prolongation[2](23,54) = -135.0/4096.0;
+      prolongation[2](23,55) = -135.0/4096.0;
+      prolongation[2](23,56) = -405.0/4096.0;
+      prolongation[2](23,57) = -405.0/4096.0;
+      prolongation[2](23,58) = -405.0/4096.0;
+      prolongation[2](23,59) = -405.0/4096.0;
+      prolongation[2](23,60) = 1215.0/4096.0;
+      prolongation[2](23,61) = 1215.0/4096.0;
+      prolongation[2](23,62) = 1215.0/4096.0;
+      prolongation[2](23,63) = 1215.0/4096.0;
+      prolongation[2](24,0) = 5.0/4096.0;
+      prolongation[2](24,1) = 5.0/4096.0;
+      prolongation[2](24,2) = 5.0/4096.0;
+      prolongation[2](24,3) = 5.0/4096.0;
+      prolongation[2](24,4) = 1.0/4096.0;
+      prolongation[2](24,5) = 1.0/4096.0;
+      prolongation[2](24,6) = 1.0/4096.0;
+      prolongation[2](24,7) = 1.0/4096.0;
+      prolongation[2](24,8) = -45.0/4096.0;
+      prolongation[2](24,9) = -45.0/4096.0;
+      prolongation[2](24,10) = -45.0/4096.0;
+      prolongation[2](24,11) = -45.0/4096.0;
+      prolongation[2](24,12) = -45.0/4096.0;
+      prolongation[2](24,13) = -45.0/4096.0;
+      prolongation[2](24,14) = -45.0/4096.0;
+      prolongation[2](24,15) = -45.0/4096.0;
+      prolongation[2](24,16) = -9.0/4096.0;
+      prolongation[2](24,17) = -9.0/4096.0;
+      prolongation[2](24,18) = -9.0/4096.0;
+      prolongation[2](24,19) = -9.0/4096.0;
+      prolongation[2](24,20) = -9.0/4096.0;
+      prolongation[2](24,21) = -9.0/4096.0;
+      prolongation[2](24,22) = -9.0/4096.0;
+      prolongation[2](24,23) = -9.0/4096.0;
+      prolongation[2](24,24) = 15.0/4096.0;
+      prolongation[2](24,25) = -5.0/4096.0;
+      prolongation[2](24,26) = 15.0/4096.0;
+      prolongation[2](24,27) = -5.0/4096.0;
+      prolongation[2](24,28) = 15.0/4096.0;
+      prolongation[2](24,29) = -5.0/4096.0;
+      prolongation[2](24,30) = 15.0/4096.0;
+      prolongation[2](24,31) = -5.0/4096.0;
+      prolongation[2](24,32) = 405.0/4096.0;
+      prolongation[2](24,33) = 405.0/4096.0;
+      prolongation[2](24,34) = 405.0/4096.0;
+      prolongation[2](24,35) = 405.0/4096.0;
+      prolongation[2](24,36) = 81.0/4096.0;
+      prolongation[2](24,37) = 81.0/4096.0;
+      prolongation[2](24,38) = 81.0/4096.0;
+      prolongation[2](24,39) = 81.0/4096.0;
+      prolongation[2](24,40) = -135.0/4096.0;
+      prolongation[2](24,41) = -135.0/4096.0;
+      prolongation[2](24,42) = 45.0/4096.0;
+      prolongation[2](24,43) = 45.0/4096.0;
+      prolongation[2](24,44) = -135.0/4096.0;
+      prolongation[2](24,45) = 45.0/4096.0;
+      prolongation[2](24,46) = -135.0/4096.0;
+      prolongation[2](24,47) = 45.0/4096.0;
+      prolongation[2](24,48) = -135.0/4096.0;
+      prolongation[2](24,49) = -135.0/4096.0;
+      prolongation[2](24,50) = 45.0/4096.0;
+      prolongation[2](24,51) = 45.0/4096.0;
+      prolongation[2](24,52) = -135.0/4096.0;
+      prolongation[2](24,53) = 45.0/4096.0;
+      prolongation[2](24,54) = -135.0/4096.0;
+      prolongation[2](24,55) = 45.0/4096.0;
+      prolongation[2](24,56) = 1215.0/4096.0;
+      prolongation[2](24,57) = 1215.0/4096.0;
+      prolongation[2](24,58) = -405.0/4096.0;
+      prolongation[2](24,59) = -405.0/4096.0;
+      prolongation[2](24,60) = 1215.0/4096.0;
+      prolongation[2](24,61) = 1215.0/4096.0;
+      prolongation[2](24,62) = -405.0/4096.0;
+      prolongation[2](24,63) = -405.0/4096.0;
+      prolongation[2](25,24) = 1.0/256.0;
+      prolongation[2](25,26) = 1.0/256.0;
+      prolongation[2](25,28) = 1.0/256.0;
+      prolongation[2](25,30) = 1.0/256.0;
+      prolongation[2](25,40) = -9.0/256.0;
+      prolongation[2](25,41) = -9.0/256.0;
+      prolongation[2](25,44) = -9.0/256.0;
+      prolongation[2](25,46) = -9.0/256.0;
+      prolongation[2](25,48) = -9.0/256.0;
+      prolongation[2](25,49) = -9.0/256.0;
+      prolongation[2](25,52) = -9.0/256.0;
+      prolongation[2](25,54) = -9.0/256.0;
+      prolongation[2](25,56) = 81.0/256.0;
+      prolongation[2](25,57) = 81.0/256.0;
+      prolongation[2](25,60) = 81.0/256.0;
+      prolongation[2](25,61) = 81.0/256.0;
+      prolongation[2](26,1) = -5.0/256.0;
+      prolongation[2](26,2) = -5.0/256.0;
+      prolongation[2](26,5) = -1.0/256.0;
+      prolongation[2](26,6) = -1.0/256.0;
+      prolongation[2](26,10) = 45.0/256.0;
+      prolongation[2](26,11) = 45.0/256.0;
+      prolongation[2](26,18) = 9.0/256.0;
+      prolongation[2](26,19) = 9.0/256.0;
+      prolongation[2](26,26) = -15.0/256.0;
+      prolongation[2](26,27) = 5.0/256.0;
+      prolongation[2](26,28) = -15.0/256.0;
+      prolongation[2](26,29) = 5.0/256.0;
+      prolongation[2](26,44) = 135.0/256.0;
+      prolongation[2](26,45) = -45.0/256.0;
+      prolongation[2](26,46) = 135.0/256.0;
+      prolongation[2](26,47) = -45.0/256.0;
+      prolongation[2](27,26) = -1.0/16.0;
+      prolongation[2](27,28) = -1.0/16.0;
+      prolongation[2](27,44) = 9.0/16.0;
+      prolongation[2](27,46) = 9.0/16.0;
+      prolongation[2](28,2) = 5.0/16.0;
+      prolongation[2](28,6) = 1.0/16.0;
+      prolongation[2](28,28) = 15.0/16.0;
+      prolongation[2](28,29) = -5.0/16.0;
+      prolongation[2](29,28) = 1.0;
+      prolongation[2](30,2) = -5.0/256.0;
+      prolongation[2](30,3) = -5.0/256.0;
+      prolongation[2](30,6) = -1.0/256.0;
+      prolongation[2](30,7) = -1.0/256.0;
+      prolongation[2](30,12) = 45.0/256.0;
+      prolongation[2](30,13) = 45.0/256.0;
+      prolongation[2](30,20) = 9.0/256.0;
+      prolongation[2](30,21) = 9.0/256.0;
+      prolongation[2](30,28) = -15.0/256.0;
+      prolongation[2](30,29) = 5.0/256.0;
+      prolongation[2](30,30) = -15.0/256.0;
+      prolongation[2](30,31) = 5.0/256.0;
+      prolongation[2](30,48) = 135.0/256.0;
+      prolongation[2](30,49) = 135.0/256.0;
+      prolongation[2](30,50) = -45.0/256.0;
+      prolongation[2](30,51) = -45.0/256.0;
+      prolongation[2](31,28) = -1.0/16.0;
+      prolongation[2](31,30) = -1.0/16.0;
+      prolongation[2](31,48) = 9.0/16.0;
+      prolongation[2](31,49) = 9.0/16.0;
+      prolongation[2](32,35) = 1.0;
+      prolongation[2](33,11) = 5.0/16.0;
+      prolongation[2](33,15) = 1.0/16.0;
+      prolongation[2](33,34) = -5.0/16.0;
+      prolongation[2](33,35) = 15.0/16.0;
+      prolongation[2](34,9) = 1.0/16.0;
+      prolongation[2](34,13) = 5.0/16.0;
+      prolongation[2](34,33) = -5.0/16.0;
+      prolongation[2](34,35) = 15.0/16.0;
+      prolongation[2](35,0) = 1.0/256.0;
+      prolongation[2](35,1) = 5.0/256.0;
+      prolongation[2](35,2) = 25.0/256.0;
+      prolongation[2](35,3) = 5.0/256.0;
+      prolongation[2](35,8) = -5.0/256.0;
+      prolongation[2](35,9) = 15.0/256.0;
+      prolongation[2](35,10) = -25.0/256.0;
+      prolongation[2](35,11) = 75.0/256.0;
+      prolongation[2](35,12) = -25.0/256.0;
+      prolongation[2](35,13) = 75.0/256.0;
+      prolongation[2](35,14) = -5.0/256.0;
+      prolongation[2](35,15) = 15.0/256.0;
+      prolongation[2](35,32) = 25.0/256.0;
+      prolongation[2](35,33) = -75.0/256.0;
+      prolongation[2](35,34) = -75.0/256.0;
+      prolongation[2](35,35) = 225.0/256.0;
+      prolongation[2](36,35) = -1.0/16.0;
+      prolongation[2](36,39) = -1.0/16.0;
+      prolongation[2](36,61) = 9.0/16.0;
+      prolongation[2](36,63) = 9.0/16.0;
+      prolongation[2](37,11) = -5.0/256.0;
+      prolongation[2](37,15) = -1.0/256.0;
+      prolongation[2](37,19) = -5.0/256.0;
+      prolongation[2](37,23) = -1.0/256.0;
+      prolongation[2](37,34) = 5.0/256.0;
+      prolongation[2](37,35) = -15.0/256.0;
+      prolongation[2](37,38) = 5.0/256.0;
+      prolongation[2](37,39) = -15.0/256.0;
+      prolongation[2](37,46) = 45.0/256.0;
+      prolongation[2](37,47) = 45.0/256.0;
+      prolongation[2](37,54) = 9.0/256.0;
+      prolongation[2](37,55) = 9.0/256.0;
+      prolongation[2](37,60) = -45.0/256.0;
+      prolongation[2](37,61) = 135.0/256.0;
+      prolongation[2](37,62) = -45.0/256.0;
+      prolongation[2](37,63) = 135.0/256.0;
+      prolongation[2](38,9) = -1.0/256.0;
+      prolongation[2](38,13) = -5.0/256.0;
+      prolongation[2](38,17) = -1.0/256.0;
+      prolongation[2](38,21) = -5.0/256.0;
+      prolongation[2](38,33) = 5.0/256.0;
+      prolongation[2](38,35) = -15.0/256.0;
+      prolongation[2](38,37) = 5.0/256.0;
+      prolongation[2](38,39) = -15.0/256.0;
+      prolongation[2](38,41) = 9.0/256.0;
+      prolongation[2](38,43) = 9.0/256.0;
+      prolongation[2](38,49) = 45.0/256.0;
+      prolongation[2](38,51) = 45.0/256.0;
+      prolongation[2](38,57) = -45.0/256.0;
+      prolongation[2](38,59) = -45.0/256.0;
+      prolongation[2](38,61) = 135.0/256.0;
+      prolongation[2](38,63) = 135.0/256.0;
+      prolongation[2](39,0) = -1.0/4096.0;
+      prolongation[2](39,1) = -5.0/4096.0;
+      prolongation[2](39,2) = -25.0/4096.0;
+      prolongation[2](39,3) = -5.0/4096.0;
+      prolongation[2](39,4) = -1.0/4096.0;
+      prolongation[2](39,5) = -5.0/4096.0;
+      prolongation[2](39,6) = -25.0/4096.0;
+      prolongation[2](39,7) = -5.0/4096.0;
+      prolongation[2](39,8) = 5.0/4096.0;
+      prolongation[2](39,9) = -15.0/4096.0;
+      prolongation[2](39,10) = 25.0/4096.0;
+      prolongation[2](39,11) = -75.0/4096.0;
+      prolongation[2](39,12) = 25.0/4096.0;
+      prolongation[2](39,13) = -75.0/4096.0;
+      prolongation[2](39,14) = 5.0/4096.0;
+      prolongation[2](39,15) = -15.0/4096.0;
+      prolongation[2](39,16) = 5.0/4096.0;
+      prolongation[2](39,17) = -15.0/4096.0;
+      prolongation[2](39,18) = 25.0/4096.0;
+      prolongation[2](39,19) = -75.0/4096.0;
+      prolongation[2](39,20) = 25.0/4096.0;
+      prolongation[2](39,21) = -75.0/4096.0;
+      prolongation[2](39,22) = 5.0/4096.0;
+      prolongation[2](39,23) = -15.0/4096.0;
+      prolongation[2](39,24) = 9.0/4096.0;
+      prolongation[2](39,25) = 9.0/4096.0;
+      prolongation[2](39,26) = 45.0/4096.0;
+      prolongation[2](39,27) = 45.0/4096.0;
+      prolongation[2](39,28) = 225.0/4096.0;
+      prolongation[2](39,29) = 225.0/4096.0;
+      prolongation[2](39,30) = 45.0/4096.0;
+      prolongation[2](39,31) = 45.0/4096.0;
+      prolongation[2](39,32) = -25.0/4096.0;
+      prolongation[2](39,33) = 75.0/4096.0;
+      prolongation[2](39,34) = 75.0/4096.0;
+      prolongation[2](39,35) = -225.0/4096.0;
+      prolongation[2](39,36) = -25.0/4096.0;
+      prolongation[2](39,37) = 75.0/4096.0;
+      prolongation[2](39,38) = 75.0/4096.0;
+      prolongation[2](39,39) = -225.0/4096.0;
+      prolongation[2](39,40) = -45.0/4096.0;
+      prolongation[2](39,41) = 135.0/4096.0;
+      prolongation[2](39,42) = -45.0/4096.0;
+      prolongation[2](39,43) = 135.0/4096.0;
+      prolongation[2](39,44) = -225.0/4096.0;
+      prolongation[2](39,45) = -225.0/4096.0;
+      prolongation[2](39,46) = 675.0/4096.0;
+      prolongation[2](39,47) = 675.0/4096.0;
+      prolongation[2](39,48) = -225.0/4096.0;
+      prolongation[2](39,49) = 675.0/4096.0;
+      prolongation[2](39,50) = -225.0/4096.0;
+      prolongation[2](39,51) = 675.0/4096.0;
+      prolongation[2](39,52) = -45.0/4096.0;
+      prolongation[2](39,53) = -45.0/4096.0;
+      prolongation[2](39,54) = 135.0/4096.0;
+      prolongation[2](39,55) = 135.0/4096.0;
+      prolongation[2](39,56) = 225.0/4096.0;
+      prolongation[2](39,57) = -675.0/4096.0;
+      prolongation[2](39,58) = 225.0/4096.0;
+      prolongation[2](39,59) = -675.0/4096.0;
+      prolongation[2](39,60) = -675.0/4096.0;
+      prolongation[2](39,61) = 2025.0/4096.0;
+      prolongation[2](39,62) = -675.0/4096.0;
+      prolongation[2](39,63) = 2025.0/4096.0;
+      prolongation[2](40,9) = -5.0/256.0;
+      prolongation[2](40,13) = -5.0/256.0;
+      prolongation[2](40,17) = -1.0/256.0;
+      prolongation[2](40,21) = -1.0/256.0;
+      prolongation[2](40,33) = 45.0/256.0;
+      prolongation[2](40,35) = 45.0/256.0;
+      prolongation[2](40,37) = 9.0/256.0;
+      prolongation[2](40,39) = 9.0/256.0;
+      prolongation[2](40,41) = -15.0/256.0;
+      prolongation[2](40,43) = 5.0/256.0;
+      prolongation[2](40,49) = -15.0/256.0;
+      prolongation[2](40,51) = 5.0/256.0;
+      prolongation[2](40,57) = 135.0/256.0;
+      prolongation[2](40,59) = -45.0/256.0;
+      prolongation[2](40,61) = 135.0/256.0;
+      prolongation[2](40,63) = -45.0/256.0;
+      prolongation[2](41,0) = -5.0/4096.0;
+      prolongation[2](41,1) = -25.0/4096.0;
+      prolongation[2](41,2) = -25.0/4096.0;
+      prolongation[2](41,3) = -5.0/4096.0;
+      prolongation[2](41,4) = -1.0/4096.0;
+      prolongation[2](41,5) = -5.0/4096.0;
+      prolongation[2](41,6) = -5.0/4096.0;
+      prolongation[2](41,7) = -1.0/4096.0;
+      prolongation[2](41,8) = 25.0/4096.0;
+      prolongation[2](41,9) = -75.0/4096.0;
+      prolongation[2](41,10) = 225.0/4096.0;
+      prolongation[2](41,11) = 225.0/4096.0;
+      prolongation[2](41,12) = 25.0/4096.0;
+      prolongation[2](41,13) = -75.0/4096.0;
+      prolongation[2](41,14) = 45.0/4096.0;
+      prolongation[2](41,15) = 45.0/4096.0;
+      prolongation[2](41,16) = 5.0/4096.0;
+      prolongation[2](41,17) = -15.0/4096.0;
+      prolongation[2](41,18) = 45.0/4096.0;
+      prolongation[2](41,19) = 45.0/4096.0;
+      prolongation[2](41,20) = 5.0/4096.0;
+      prolongation[2](41,21) = -15.0/4096.0;
+      prolongation[2](41,22) = 9.0/4096.0;
+      prolongation[2](41,23) = 9.0/4096.0;
+      prolongation[2](41,24) = -15.0/4096.0;
+      prolongation[2](41,25) = 5.0/4096.0;
+      prolongation[2](41,26) = -75.0/4096.0;
+      prolongation[2](41,27) = 25.0/4096.0;
+      prolongation[2](41,28) = -75.0/4096.0;
+      prolongation[2](41,29) = 25.0/4096.0;
+      prolongation[2](41,30) = -15.0/4096.0;
+      prolongation[2](41,31) = 5.0/4096.0;
+      prolongation[2](41,32) = -225.0/4096.0;
+      prolongation[2](41,33) = 675.0/4096.0;
+      prolongation[2](41,34) = -225.0/4096.0;
+      prolongation[2](41,35) = 675.0/4096.0;
+      prolongation[2](41,36) = -45.0/4096.0;
+      prolongation[2](41,37) = 135.0/4096.0;
+      prolongation[2](41,38) = -45.0/4096.0;
+      prolongation[2](41,39) = 135.0/4096.0;
+      prolongation[2](41,40) = 75.0/4096.0;
+      prolongation[2](41,41) = -225.0/4096.0;
+      prolongation[2](41,42) = -25.0/4096.0;
+      prolongation[2](41,43) = 75.0/4096.0;
+      prolongation[2](41,44) = 675.0/4096.0;
+      prolongation[2](41,45) = -225.0/4096.0;
+      prolongation[2](41,46) = 675.0/4096.0;
+      prolongation[2](41,47) = -225.0/4096.0;
+      prolongation[2](41,48) = 75.0/4096.0;
+      prolongation[2](41,49) = -225.0/4096.0;
+      prolongation[2](41,50) = -25.0/4096.0;
+      prolongation[2](41,51) = 75.0/4096.0;
+      prolongation[2](41,52) = 135.0/4096.0;
+      prolongation[2](41,53) = -45.0/4096.0;
+      prolongation[2](41,54) = 135.0/4096.0;
+      prolongation[2](41,55) = -45.0/4096.0;
+      prolongation[2](41,56) = -675.0/4096.0;
+      prolongation[2](41,57) = 2025.0/4096.0;
+      prolongation[2](41,58) = 225.0/4096.0;
+      prolongation[2](41,59) = -675.0/4096.0;
+      prolongation[2](41,60) = -675.0/4096.0;
+      prolongation[2](41,61) = 2025.0/4096.0;
+      prolongation[2](41,62) = 225.0/4096.0;
+      prolongation[2](41,63) = -675.0/4096.0;
+      prolongation[2](42,41) = -1.0/16.0;
+      prolongation[2](42,49) = -1.0/16.0;
+      prolongation[2](42,57) = 9.0/16.0;
+      prolongation[2](42,61) = 9.0/16.0;
+      prolongation[2](43,24) = -1.0/256.0;
+      prolongation[2](43,26) = -5.0/256.0;
+      prolongation[2](43,28) = -5.0/256.0;
+      prolongation[2](43,30) = -1.0/256.0;
+      prolongation[2](43,40) = 5.0/256.0;
+      prolongation[2](43,41) = -15.0/256.0;
+      prolongation[2](43,44) = 45.0/256.0;
+      prolongation[2](43,46) = 45.0/256.0;
+      prolongation[2](43,48) = 5.0/256.0;
+      prolongation[2](43,49) = -15.0/256.0;
+      prolongation[2](43,52) = 9.0/256.0;
+      prolongation[2](43,54) = 9.0/256.0;
+      prolongation[2](43,56) = -45.0/256.0;
+      prolongation[2](43,57) = 135.0/256.0;
+      prolongation[2](43,60) = -45.0/256.0;
+      prolongation[2](43,61) = 135.0/256.0;
+      prolongation[2](44,11) = 5.0/16.0;
+      prolongation[2](44,19) = 1.0/16.0;
+      prolongation[2](44,46) = 15.0/16.0;
+      prolongation[2](44,47) = -5.0/16.0;
+      prolongation[2](45,46) = 1.0;
+      prolongation[2](46,1) = 5.0/256.0;
+      prolongation[2](46,2) = 25.0/256.0;
+      prolongation[2](46,5) = 1.0/256.0;
+      prolongation[2](46,6) = 5.0/256.0;
+      prolongation[2](46,10) = -25.0/256.0;
+      prolongation[2](46,11) = 75.0/256.0;
+      prolongation[2](46,18) = -5.0/256.0;
+      prolongation[2](46,19) = 15.0/256.0;
+      prolongation[2](46,26) = 15.0/256.0;
+      prolongation[2](46,27) = -5.0/256.0;
+      prolongation[2](46,28) = 75.0/256.0;
+      prolongation[2](46,29) = -25.0/256.0;
+      prolongation[2](46,44) = -75.0/256.0;
+      prolongation[2](46,45) = 25.0/256.0;
+      prolongation[2](46,46) = 225.0/256.0;
+      prolongation[2](46,47) = -75.0/256.0;
+      prolongation[2](47,26) = 1.0/16.0;
+      prolongation[2](47,28) = 5.0/16.0;
+      prolongation[2](47,44) = -5.0/16.0;
+      prolongation[2](47,46) = 15.0/16.0;
+      prolongation[2](48,13) = 5.0/16.0;
+      prolongation[2](48,21) = 1.0/16.0;
+      prolongation[2](48,49) = 15.0/16.0;
+      prolongation[2](48,51) = -5.0/16.0;
+      prolongation[2](49,2) = 25.0/256.0;
+      prolongation[2](49,3) = 5.0/256.0;
+      prolongation[2](49,6) = 5.0/256.0;
+      prolongation[2](49,7) = 1.0/256.0;
+      prolongation[2](49,12) = -25.0/256.0;
+      prolongation[2](49,13) = 75.0/256.0;
+      prolongation[2](49,20) = -5.0/256.0;
+      prolongation[2](49,21) = 15.0/256.0;
+      prolongation[2](49,28) = 75.0/256.0;
+      prolongation[2](49,29) = -25.0/256.0;
+      prolongation[2](49,30) = 15.0/256.0;
+      prolongation[2](49,31) = -5.0/256.0;
+      prolongation[2](49,48) = -75.0/256.0;
+      prolongation[2](49,49) = 225.0/256.0;
+      prolongation[2](49,50) = 25.0/256.0;
+      prolongation[2](49,51) = -75.0/256.0;
+      prolongation[2](50,49) = 1.0;
+      prolongation[2](51,28) = 5.0/16.0;
+      prolongation[2](51,30) = 1.0/16.0;
+      prolongation[2](51,48) = -5.0/16.0;
+      prolongation[2](51,49) = 15.0/16.0;
+      prolongation[2](52,11) = -5.0/256.0;
+      prolongation[2](52,15) = -5.0/256.0;
+      prolongation[2](52,19) = -1.0/256.0;
+      prolongation[2](52,23) = -1.0/256.0;
+      prolongation[2](52,34) = 45.0/256.0;
+      prolongation[2](52,35) = 45.0/256.0;
+      prolongation[2](52,38) = 9.0/256.0;
+      prolongation[2](52,39) = 9.0/256.0;
+      prolongation[2](52,46) = -15.0/256.0;
+      prolongation[2](52,47) = 5.0/256.0;
+      prolongation[2](52,54) = -15.0/256.0;
+      prolongation[2](52,55) = 5.0/256.0;
+      prolongation[2](52,60) = 135.0/256.0;
+      prolongation[2](52,61) = 135.0/256.0;
+      prolongation[2](52,62) = -45.0/256.0;
+      prolongation[2](52,63) = -45.0/256.0;
+      prolongation[2](53,46) = -1.0/16.0;
+      prolongation[2](53,54) = -1.0/16.0;
+      prolongation[2](53,60) = 9.0/16.0;
+      prolongation[2](53,61) = 9.0/16.0;
+      prolongation[2](54,0) = -5.0/4096.0;
+      prolongation[2](54,1) = -5.0/4096.0;
+      prolongation[2](54,2) = -25.0/4096.0;
+      prolongation[2](54,3) = -25.0/4096.0;
+      prolongation[2](54,4) = -1.0/4096.0;
+      prolongation[2](54,5) = -1.0/4096.0;
+      prolongation[2](54,6) = -5.0/4096.0;
+      prolongation[2](54,7) = -5.0/4096.0;
+      prolongation[2](54,8) = 45.0/4096.0;
+      prolongation[2](54,9) = 45.0/4096.0;
+      prolongation[2](54,10) = 25.0/4096.0;
+      prolongation[2](54,11) = -75.0/4096.0;
+      prolongation[2](54,12) = 225.0/4096.0;
+      prolongation[2](54,13) = 225.0/4096.0;
+      prolongation[2](54,14) = 25.0/4096.0;
+      prolongation[2](54,15) = -75.0/4096.0;
+      prolongation[2](54,16) = 9.0/4096.0;
+      prolongation[2](54,17) = 9.0/4096.0;
+      prolongation[2](54,18) = 5.0/4096.0;
+      prolongation[2](54,19) = -15.0/4096.0;
+      prolongation[2](54,20) = 45.0/4096.0;
+      prolongation[2](54,21) = 45.0/4096.0;
+      prolongation[2](54,22) = 5.0/4096.0;
+      prolongation[2](54,23) = -15.0/4096.0;
+      prolongation[2](54,24) = -15.0/4096.0;
+      prolongation[2](54,25) = 5.0/4096.0;
+      prolongation[2](54,26) = -15.0/4096.0;
+      prolongation[2](54,27) = 5.0/4096.0;
+      prolongation[2](54,28) = -75.0/4096.0;
+      prolongation[2](54,29) = 25.0/4096.0;
+      prolongation[2](54,30) = -75.0/4096.0;
+      prolongation[2](54,31) = 25.0/4096.0;
+      prolongation[2](54,32) = -225.0/4096.0;
+      prolongation[2](54,33) = -225.0/4096.0;
+      prolongation[2](54,34) = 675.0/4096.0;
+      prolongation[2](54,35) = 675.0/4096.0;
+      prolongation[2](54,36) = -45.0/4096.0;
+      prolongation[2](54,37) = -45.0/4096.0;
+      prolongation[2](54,38) = 135.0/4096.0;
+      prolongation[2](54,39) = 135.0/4096.0;
+      prolongation[2](54,40) = 135.0/4096.0;
+      prolongation[2](54,41) = 135.0/4096.0;
+      prolongation[2](54,42) = -45.0/4096.0;
+      prolongation[2](54,43) = -45.0/4096.0;
+      prolongation[2](54,44) = 75.0/4096.0;
+      prolongation[2](54,45) = -25.0/4096.0;
+      prolongation[2](54,46) = -225.0/4096.0;
+      prolongation[2](54,47) = 75.0/4096.0;
+      prolongation[2](54,48) = 675.0/4096.0;
+      prolongation[2](54,49) = 675.0/4096.0;
+      prolongation[2](54,50) = -225.0/4096.0;
+      prolongation[2](54,51) = -225.0/4096.0;
+      prolongation[2](54,52) = 75.0/4096.0;
+      prolongation[2](54,53) = -25.0/4096.0;
+      prolongation[2](54,54) = -225.0/4096.0;
+      prolongation[2](54,55) = 75.0/4096.0;
+      prolongation[2](54,56) = -675.0/4096.0;
+      prolongation[2](54,57) = -675.0/4096.0;
+      prolongation[2](54,58) = 225.0/4096.0;
+      prolongation[2](54,59) = 225.0/4096.0;
+      prolongation[2](54,60) = 2025.0/4096.0;
+      prolongation[2](54,61) = 2025.0/4096.0;
+      prolongation[2](54,62) = -675.0/4096.0;
+      prolongation[2](54,63) = -675.0/4096.0;
+      prolongation[2](55,24) = -1.0/256.0;
+      prolongation[2](55,26) = -1.0/256.0;
+      prolongation[2](55,28) = -5.0/256.0;
+      prolongation[2](55,30) = -5.0/256.0;
+      prolongation[2](55,40) = 9.0/256.0;
+      prolongation[2](55,41) = 9.0/256.0;
+      prolongation[2](55,44) = 5.0/256.0;
+      prolongation[2](55,46) = -15.0/256.0;
+      prolongation[2](55,48) = 45.0/256.0;
+      prolongation[2](55,49) = 45.0/256.0;
+      prolongation[2](55,52) = 5.0/256.0;
+      prolongation[2](55,54) = -15.0/256.0;
+      prolongation[2](55,56) = -45.0/256.0;
+      prolongation[2](55,57) = -45.0/256.0;
+      prolongation[2](55,60) = 135.0/256.0;
+      prolongation[2](55,61) = 135.0/256.0;
+      prolongation[2](56,35) = 5.0/16.0;
+      prolongation[2](56,39) = 1.0/16.0;
+      prolongation[2](56,61) = 15.0/16.0;
+      prolongation[2](56,63) = -5.0/16.0;
+      prolongation[2](57,11) = 25.0/256.0;
+      prolongation[2](57,15) = 5.0/256.0;
+      prolongation[2](57,19) = 5.0/256.0;
+      prolongation[2](57,23) = 1.0/256.0;
+      prolongation[2](57,34) = -25.0/256.0;
+      prolongation[2](57,35) = 75.0/256.0;
+      prolongation[2](57,38) = -5.0/256.0;
+      prolongation[2](57,39) = 15.0/256.0;
+      prolongation[2](57,46) = 75.0/256.0;
+      prolongation[2](57,47) = -25.0/256.0;
+      prolongation[2](57,54) = 15.0/256.0;
+      prolongation[2](57,55) = -5.0/256.0;
+      prolongation[2](57,60) = -75.0/256.0;
+      prolongation[2](57,61) = 225.0/256.0;
+      prolongation[2](57,62) = 25.0/256.0;
+      prolongation[2](57,63) = -75.0/256.0;
+      prolongation[2](58,61) = 1.0;
+      prolongation[2](59,46) = 5.0/16.0;
+      prolongation[2](59,54) = 1.0/16.0;
+      prolongation[2](59,60) = -5.0/16.0;
+      prolongation[2](59,61) = 15.0/16.0;
+      prolongation[2](60,9) = 5.0/256.0;
+      prolongation[2](60,13) = 25.0/256.0;
+      prolongation[2](60,17) = 1.0/256.0;
+      prolongation[2](60,21) = 5.0/256.0;
+      prolongation[2](60,33) = -25.0/256.0;
+      prolongation[2](60,35) = 75.0/256.0;
+      prolongation[2](60,37) = -5.0/256.0;
+      prolongation[2](60,39) = 15.0/256.0;
+      prolongation[2](60,41) = 15.0/256.0;
+      prolongation[2](60,43) = -5.0/256.0;
+      prolongation[2](60,49) = 75.0/256.0;
+      prolongation[2](60,51) = -25.0/256.0;
+      prolongation[2](60,57) = -75.0/256.0;
+      prolongation[2](60,59) = 25.0/256.0;
+      prolongation[2](60,61) = 225.0/256.0;
+      prolongation[2](60,63) = -75.0/256.0;
+      prolongation[2](61,0) = 5.0/4096.0;
+      prolongation[2](61,1) = 25.0/4096.0;
+      prolongation[2](61,2) = 125.0/4096.0;
+      prolongation[2](61,3) = 25.0/4096.0;
+      prolongation[2](61,4) = 1.0/4096.0;
+      prolongation[2](61,5) = 5.0/4096.0;
+      prolongation[2](61,6) = 25.0/4096.0;
+      prolongation[2](61,7) = 5.0/4096.0;
+      prolongation[2](61,8) = -25.0/4096.0;
+      prolongation[2](61,9) = 75.0/4096.0;
+      prolongation[2](61,10) = -125.0/4096.0;
+      prolongation[2](61,11) = 375.0/4096.0;
+      prolongation[2](61,12) = -125.0/4096.0;
+      prolongation[2](61,13) = 375.0/4096.0;
+      prolongation[2](61,14) = -25.0/4096.0;
+      prolongation[2](61,15) = 75.0/4096.0;
+      prolongation[2](61,16) = -5.0/4096.0;
+      prolongation[2](61,17) = 15.0/4096.0;
+      prolongation[2](61,18) = -25.0/4096.0;
+      prolongation[2](61,19) = 75.0/4096.0;
+      prolongation[2](61,20) = -25.0/4096.0;
+      prolongation[2](61,21) = 75.0/4096.0;
+      prolongation[2](61,22) = -5.0/4096.0;
+      prolongation[2](61,23) = 15.0/4096.0;
+      prolongation[2](61,24) = 15.0/4096.0;
+      prolongation[2](61,25) = -5.0/4096.0;
+      prolongation[2](61,26) = 75.0/4096.0;
+      prolongation[2](61,27) = -25.0/4096.0;
+      prolongation[2](61,28) = 375.0/4096.0;
+      prolongation[2](61,29) = -125.0/4096.0;
+      prolongation[2](61,30) = 75.0/4096.0;
+      prolongation[2](61,31) = -25.0/4096.0;
+      prolongation[2](61,32) = 125.0/4096.0;
+      prolongation[2](61,33) = -375.0/4096.0;
+      prolongation[2](61,34) = -375.0/4096.0;
+      prolongation[2](61,35) = 1125.0/4096.0;
+      prolongation[2](61,36) = 25.0/4096.0;
+      prolongation[2](61,37) = -75.0/4096.0;
+      prolongation[2](61,38) = -75.0/4096.0;
+      prolongation[2](61,39) = 225.0/4096.0;
+      prolongation[2](61,40) = -75.0/4096.0;
+      prolongation[2](61,41) = 225.0/4096.0;
+      prolongation[2](61,42) = 25.0/4096.0;
+      prolongation[2](61,43) = -75.0/4096.0;
+      prolongation[2](61,44) = -375.0/4096.0;
+      prolongation[2](61,45) = 125.0/4096.0;
+      prolongation[2](61,46) = 1125.0/4096.0;
+      prolongation[2](61,47) = -375.0/4096.0;
+      prolongation[2](61,48) = -375.0/4096.0;
+      prolongation[2](61,49) = 1125.0/4096.0;
+      prolongation[2](61,50) = 125.0/4096.0;
+      prolongation[2](61,51) = -375.0/4096.0;
+      prolongation[2](61,52) = -75.0/4096.0;
+      prolongation[2](61,53) = 25.0/4096.0;
+      prolongation[2](61,54) = 225.0/4096.0;
+      prolongation[2](61,55) = -75.0/4096.0;
+      prolongation[2](61,56) = 375.0/4096.0;
+      prolongation[2](61,57) = -1125.0/4096.0;
+      prolongation[2](61,58) = -125.0/4096.0;
+      prolongation[2](61,59) = 375.0/4096.0;
+      prolongation[2](61,60) = -1125.0/4096.0;
+      prolongation[2](61,61) = 3375.0/4096.0;
+      prolongation[2](61,62) = 375.0/4096.0;
+      prolongation[2](61,63) = -1125.0/4096.0;
+      prolongation[2](62,41) = 1.0/16.0;
+      prolongation[2](62,49) = 5.0/16.0;
+      prolongation[2](62,57) = -5.0/16.0;
+      prolongation[2](62,61) = 15.0/16.0;
+      prolongation[2](63,24) = 1.0/256.0;
+      prolongation[2](63,26) = 5.0/256.0;
+      prolongation[2](63,28) = 25.0/256.0;
+      prolongation[2](63,30) = 5.0/256.0;
+      prolongation[2](63,40) = -5.0/256.0;
+      prolongation[2](63,41) = 15.0/256.0;
+      prolongation[2](63,44) = -25.0/256.0;
+      prolongation[2](63,46) = 75.0/256.0;
+      prolongation[2](63,48) = -25.0/256.0;
+      prolongation[2](63,49) = 75.0/256.0;
+      prolongation[2](63,52) = -5.0/256.0;
+      prolongation[2](63,54) = 15.0/256.0;
+      prolongation[2](63,56) = 25.0/256.0;
+      prolongation[2](63,57) = -75.0/256.0;
+      prolongation[2](63,60) = -75.0/256.0;
+      prolongation[2](63,61) = 225.0/256.0;
+      prolongation[3](0,0) = -1.0/16.0;
+      prolongation[3](0,3) = -1.0/16.0;
+      prolongation[3](0,14) = 9.0/16.0;
+      prolongation[3](0,15) = 9.0/16.0;
+      prolongation[3](1,0) = 1.0/256.0;
+      prolongation[3](1,1) = 1.0/256.0;
+      prolongation[3](1,2) = 1.0/256.0;
+      prolongation[3](1,3) = 1.0/256.0;
+      prolongation[3](1,8) = -9.0/256.0;
+      prolongation[3](1,9) = -9.0/256.0;
+      prolongation[3](1,10) = -9.0/256.0;
+      prolongation[3](1,11) = -9.0/256.0;
+      prolongation[3](1,12) = -9.0/256.0;
+      prolongation[3](1,13) = -9.0/256.0;
+      prolongation[3](1,14) = -9.0/256.0;
+      prolongation[3](1,15) = -9.0/256.0;
+      prolongation[3](1,32) = 81.0/256.0;
+      prolongation[3](1,33) = 81.0/256.0;
+      prolongation[3](1,34) = 81.0/256.0;
+      prolongation[3](1,35) = 81.0/256.0;
+      prolongation[3](2,2) = -1.0/16.0;
+      prolongation[3](2,3) = -1.0/16.0;
+      prolongation[3](2,12) = 9.0/16.0;
+      prolongation[3](2,13) = 9.0/16.0;
+      prolongation[3](3,3) = 1.0;
+      prolongation[3](4,0) = 1.0/256.0;
+      prolongation[3](4,3) = 1.0/256.0;
+      prolongation[3](4,4) = 1.0/256.0;
+      prolongation[3](4,7) = 1.0/256.0;
+      prolongation[3](4,14) = -9.0/256.0;
+      prolongation[3](4,15) = -9.0/256.0;
+      prolongation[3](4,22) = -9.0/256.0;
+      prolongation[3](4,23) = -9.0/256.0;
+      prolongation[3](4,24) = -9.0/256.0;
+      prolongation[3](4,25) = -9.0/256.0;
+      prolongation[3](4,30) = -9.0/256.0;
+      prolongation[3](4,31) = -9.0/256.0;
+      prolongation[3](4,52) = 81.0/256.0;
+      prolongation[3](4,53) = 81.0/256.0;
+      prolongation[3](4,54) = 81.0/256.0;
+      prolongation[3](4,55) = 81.0/256.0;
+      prolongation[3](5,0) = -1.0/4096.0;
+      prolongation[3](5,1) = -1.0/4096.0;
+      prolongation[3](5,2) = -1.0/4096.0;
+      prolongation[3](5,3) = -1.0/4096.0;
+      prolongation[3](5,4) = -1.0/4096.0;
+      prolongation[3](5,5) = -1.0/4096.0;
+      prolongation[3](5,6) = -1.0/4096.0;
+      prolongation[3](5,7) = -1.0/4096.0;
+      prolongation[3](5,8) = 9.0/4096.0;
+      prolongation[3](5,9) = 9.0/4096.0;
+      prolongation[3](5,10) = 9.0/4096.0;
+      prolongation[3](5,11) = 9.0/4096.0;
+      prolongation[3](5,12) = 9.0/4096.0;
+      prolongation[3](5,13) = 9.0/4096.0;
+      prolongation[3](5,14) = 9.0/4096.0;
+      prolongation[3](5,15) = 9.0/4096.0;
+      prolongation[3](5,16) = 9.0/4096.0;
+      prolongation[3](5,17) = 9.0/4096.0;
+      prolongation[3](5,18) = 9.0/4096.0;
+      prolongation[3](5,19) = 9.0/4096.0;
+      prolongation[3](5,20) = 9.0/4096.0;
+      prolongation[3](5,21) = 9.0/4096.0;
+      prolongation[3](5,22) = 9.0/4096.0;
+      prolongation[3](5,23) = 9.0/4096.0;
+      prolongation[3](5,24) = 9.0/4096.0;
+      prolongation[3](5,25) = 9.0/4096.0;
+      prolongation[3](5,26) = 9.0/4096.0;
+      prolongation[3](5,27) = 9.0/4096.0;
+      prolongation[3](5,28) = 9.0/4096.0;
+      prolongation[3](5,29) = 9.0/4096.0;
+      prolongation[3](5,30) = 9.0/4096.0;
+      prolongation[3](5,31) = 9.0/4096.0;
+      prolongation[3](5,32) = -81.0/4096.0;
+      prolongation[3](5,33) = -81.0/4096.0;
+      prolongation[3](5,34) = -81.0/4096.0;
+      prolongation[3](5,35) = -81.0/4096.0;
+      prolongation[3](5,36) = -81.0/4096.0;
+      prolongation[3](5,37) = -81.0/4096.0;
+      prolongation[3](5,38) = -81.0/4096.0;
+      prolongation[3](5,39) = -81.0/4096.0;
+      prolongation[3](5,40) = -81.0/4096.0;
+      prolongation[3](5,41) = -81.0/4096.0;
+      prolongation[3](5,42) = -81.0/4096.0;
+      prolongation[3](5,43) = -81.0/4096.0;
+      prolongation[3](5,44) = -81.0/4096.0;
+      prolongation[3](5,45) = -81.0/4096.0;
+      prolongation[3](5,46) = -81.0/4096.0;
+      prolongation[3](5,47) = -81.0/4096.0;
+      prolongation[3](5,48) = -81.0/4096.0;
+      prolongation[3](5,49) = -81.0/4096.0;
+      prolongation[3](5,50) = -81.0/4096.0;
+      prolongation[3](5,51) = -81.0/4096.0;
+      prolongation[3](5,52) = -81.0/4096.0;
+      prolongation[3](5,53) = -81.0/4096.0;
+      prolongation[3](5,54) = -81.0/4096.0;
+      prolongation[3](5,55) = -81.0/4096.0;
+      prolongation[3](5,56) = 729.0/4096.0;
+      prolongation[3](5,57) = 729.0/4096.0;
+      prolongation[3](5,58) = 729.0/4096.0;
+      prolongation[3](5,59) = 729.0/4096.0;
+      prolongation[3](5,60) = 729.0/4096.0;
+      prolongation[3](5,61) = 729.0/4096.0;
+      prolongation[3](5,62) = 729.0/4096.0;
+      prolongation[3](5,63) = 729.0/4096.0;
+      prolongation[3](6,2) = 1.0/256.0;
+      prolongation[3](6,3) = 1.0/256.0;
+      prolongation[3](6,6) = 1.0/256.0;
+      prolongation[3](6,7) = 1.0/256.0;
+      prolongation[3](6,12) = -9.0/256.0;
+      prolongation[3](6,13) = -9.0/256.0;
+      prolongation[3](6,20) = -9.0/256.0;
+      prolongation[3](6,21) = -9.0/256.0;
+      prolongation[3](6,28) = -9.0/256.0;
+      prolongation[3](6,29) = -9.0/256.0;
+      prolongation[3](6,30) = -9.0/256.0;
+      prolongation[3](6,31) = -9.0/256.0;
+      prolongation[3](6,48) = 81.0/256.0;
+      prolongation[3](6,49) = 81.0/256.0;
+      prolongation[3](6,50) = 81.0/256.0;
+      prolongation[3](6,51) = 81.0/256.0;
+      prolongation[3](7,3) = -1.0/16.0;
+      prolongation[3](7,7) = -1.0/16.0;
+      prolongation[3](7,30) = 9.0/16.0;
+      prolongation[3](7,31) = 9.0/16.0;
+      prolongation[3](8,0) = -5.0/256.0;
+      prolongation[3](8,1) = -1.0/256.0;
+      prolongation[3](8,2) = -1.0/256.0;
+      prolongation[3](8,3) = -5.0/256.0;
+      prolongation[3](8,8) = -15.0/256.0;
+      prolongation[3](8,9) = 5.0/256.0;
+      prolongation[3](8,10) = 9.0/256.0;
+      prolongation[3](8,11) = 9.0/256.0;
+      prolongation[3](8,12) = -15.0/256.0;
+      prolongation[3](8,13) = 5.0/256.0;
+      prolongation[3](8,14) = 45.0/256.0;
+      prolongation[3](8,15) = 45.0/256.0;
+      prolongation[3](8,32) = 135.0/256.0;
+      prolongation[3](8,33) = -45.0/256.0;
+      prolongation[3](8,34) = 135.0/256.0;
+      prolongation[3](8,35) = -45.0/256.0;
+      prolongation[3](9,8) = -1.0/16.0;
+      prolongation[3](9,12) = -1.0/16.0;
+      prolongation[3](9,32) = 9.0/16.0;
+      prolongation[3](9,34) = 9.0/16.0;
+      prolongation[3](10,11) = -1.0/16.0;
+      prolongation[3](10,15) = -1.0/16.0;
+      prolongation[3](10,34) = 9.0/16.0;
+      prolongation[3](10,35) = 9.0/16.0;
+      prolongation[3](11,0) = -1.0/256.0;
+      prolongation[3](11,1) = -1.0/256.0;
+      prolongation[3](11,2) = -5.0/256.0;
+      prolongation[3](11,3) = -5.0/256.0;
+      prolongation[3](11,8) = 9.0/256.0;
+      prolongation[3](11,9) = 9.0/256.0;
+      prolongation[3](11,10) = 5.0/256.0;
+      prolongation[3](11,11) = -15.0/256.0;
+      prolongation[3](11,12) = 45.0/256.0;
+      prolongation[3](11,13) = 45.0/256.0;
+      prolongation[3](11,14) = 5.0/256.0;
+      prolongation[3](11,15) = -15.0/256.0;
+      prolongation[3](11,32) = -45.0/256.0;
+      prolongation[3](11,33) = -45.0/256.0;
+      prolongation[3](11,34) = 135.0/256.0;
+      prolongation[3](11,35) = 135.0/256.0;
+      prolongation[3](12,2) = 1.0/16.0;
+      prolongation[3](12,3) = 5.0/16.0;
+      prolongation[3](12,12) = 15.0/16.0;
+      prolongation[3](12,13) = -5.0/16.0;
+      prolongation[3](13,12) = 1.0;
+      prolongation[3](14,15) = 1.0;
+      prolongation[3](15,0) = 1.0/16.0;
+      prolongation[3](15,3) = 5.0/16.0;
+      prolongation[3](15,14) = -5.0/16.0;
+      prolongation[3](15,15) = 15.0/16.0;
+      prolongation[3](16,0) = 5.0/4096.0;
+      prolongation[3](16,1) = 1.0/4096.0;
+      prolongation[3](16,2) = 1.0/4096.0;
+      prolongation[3](16,3) = 5.0/4096.0;
+      prolongation[3](16,4) = 5.0/4096.0;
+      prolongation[3](16,5) = 1.0/4096.0;
+      prolongation[3](16,6) = 1.0/4096.0;
+      prolongation[3](16,7) = 5.0/4096.0;
+      prolongation[3](16,8) = 15.0/4096.0;
+      prolongation[3](16,9) = -5.0/4096.0;
+      prolongation[3](16,10) = -9.0/4096.0;
+      prolongation[3](16,11) = -9.0/4096.0;
+      prolongation[3](16,12) = 15.0/4096.0;
+      prolongation[3](16,13) = -5.0/4096.0;
+      prolongation[3](16,14) = -45.0/4096.0;
+      prolongation[3](16,15) = -45.0/4096.0;
+      prolongation[3](16,16) = 15.0/4096.0;
+      prolongation[3](16,17) = -5.0/4096.0;
+      prolongation[3](16,18) = -9.0/4096.0;
+      prolongation[3](16,19) = -9.0/4096.0;
+      prolongation[3](16,20) = 15.0/4096.0;
+      prolongation[3](16,21) = -5.0/4096.0;
+      prolongation[3](16,22) = -45.0/4096.0;
+      prolongation[3](16,23) = -45.0/4096.0;
+      prolongation[3](16,24) = -45.0/4096.0;
+      prolongation[3](16,25) = -45.0/4096.0;
+      prolongation[3](16,26) = -9.0/4096.0;
+      prolongation[3](16,27) = -9.0/4096.0;
+      prolongation[3](16,28) = -9.0/4096.0;
+      prolongation[3](16,29) = -9.0/4096.0;
+      prolongation[3](16,30) = -45.0/4096.0;
+      prolongation[3](16,31) = -45.0/4096.0;
+      prolongation[3](16,32) = -135.0/4096.0;
+      prolongation[3](16,33) = 45.0/4096.0;
+      prolongation[3](16,34) = -135.0/4096.0;
+      prolongation[3](16,35) = 45.0/4096.0;
+      prolongation[3](16,36) = -135.0/4096.0;
+      prolongation[3](16,37) = 45.0/4096.0;
+      prolongation[3](16,38) = -135.0/4096.0;
+      prolongation[3](16,39) = 45.0/4096.0;
+      prolongation[3](16,40) = -135.0/4096.0;
+      prolongation[3](16,41) = 45.0/4096.0;
+      prolongation[3](16,42) = -135.0/4096.0;
+      prolongation[3](16,43) = 45.0/4096.0;
+      prolongation[3](16,44) = 81.0/4096.0;
+      prolongation[3](16,45) = 81.0/4096.0;
+      prolongation[3](16,46) = 81.0/4096.0;
+      prolongation[3](16,47) = 81.0/4096.0;
+      prolongation[3](16,48) = -135.0/4096.0;
+      prolongation[3](16,49) = 45.0/4096.0;
+      prolongation[3](16,50) = -135.0/4096.0;
+      prolongation[3](16,51) = 45.0/4096.0;
+      prolongation[3](16,52) = 405.0/4096.0;
+      prolongation[3](16,53) = 405.0/4096.0;
+      prolongation[3](16,54) = 405.0/4096.0;
+      prolongation[3](16,55) = 405.0/4096.0;
+      prolongation[3](16,56) = 1215.0/4096.0;
+      prolongation[3](16,57) = -405.0/4096.0;
+      prolongation[3](16,58) = 1215.0/4096.0;
+      prolongation[3](16,59) = -405.0/4096.0;
+      prolongation[3](16,60) = 1215.0/4096.0;
+      prolongation[3](16,61) = -405.0/4096.0;
+      prolongation[3](16,62) = 1215.0/4096.0;
+      prolongation[3](16,63) = -405.0/4096.0;
+      prolongation[3](17,8) = 1.0/256.0;
+      prolongation[3](17,12) = 1.0/256.0;
+      prolongation[3](17,16) = 1.0/256.0;
+      prolongation[3](17,20) = 1.0/256.0;
+      prolongation[3](17,32) = -9.0/256.0;
+      prolongation[3](17,34) = -9.0/256.0;
+      prolongation[3](17,36) = -9.0/256.0;
+      prolongation[3](17,38) = -9.0/256.0;
+      prolongation[3](17,40) = -9.0/256.0;
+      prolongation[3](17,42) = -9.0/256.0;
+      prolongation[3](17,48) = -9.0/256.0;
+      prolongation[3](17,50) = -9.0/256.0;
+      prolongation[3](17,56) = 81.0/256.0;
+      prolongation[3](17,58) = 81.0/256.0;
+      prolongation[3](17,60) = 81.0/256.0;
+      prolongation[3](17,62) = 81.0/256.0;
+      prolongation[3](18,11) = 1.0/256.0;
+      prolongation[3](18,15) = 1.0/256.0;
+      prolongation[3](18,19) = 1.0/256.0;
+      prolongation[3](18,23) = 1.0/256.0;
+      prolongation[3](18,34) = -9.0/256.0;
+      prolongation[3](18,35) = -9.0/256.0;
+      prolongation[3](18,38) = -9.0/256.0;
+      prolongation[3](18,39) = -9.0/256.0;
+      prolongation[3](18,46) = -9.0/256.0;
+      prolongation[3](18,47) = -9.0/256.0;
+      prolongation[3](18,54) = -9.0/256.0;
+      prolongation[3](18,55) = -9.0/256.0;
+      prolongation[3](18,60) = 81.0/256.0;
+      prolongation[3](18,61) = 81.0/256.0;
+      prolongation[3](18,62) = 81.0/256.0;
+      prolongation[3](18,63) = 81.0/256.0;
+      prolongation[3](19,0) = 1.0/4096.0;
+      prolongation[3](19,1) = 1.0/4096.0;
+      prolongation[3](19,2) = 5.0/4096.0;
+      prolongation[3](19,3) = 5.0/4096.0;
+      prolongation[3](19,4) = 1.0/4096.0;
+      prolongation[3](19,5) = 1.0/4096.0;
+      prolongation[3](19,6) = 5.0/4096.0;
+      prolongation[3](19,7) = 5.0/4096.0;
+      prolongation[3](19,8) = -9.0/4096.0;
+      prolongation[3](19,9) = -9.0/4096.0;
+      prolongation[3](19,10) = -5.0/4096.0;
+      prolongation[3](19,11) = 15.0/4096.0;
+      prolongation[3](19,12) = -45.0/4096.0;
+      prolongation[3](19,13) = -45.0/4096.0;
+      prolongation[3](19,14) = -5.0/4096.0;
+      prolongation[3](19,15) = 15.0/4096.0;
+      prolongation[3](19,16) = -9.0/4096.0;
+      prolongation[3](19,17) = -9.0/4096.0;
+      prolongation[3](19,18) = -5.0/4096.0;
+      prolongation[3](19,19) = 15.0/4096.0;
+      prolongation[3](19,20) = -45.0/4096.0;
+      prolongation[3](19,21) = -45.0/4096.0;
+      prolongation[3](19,22) = -5.0/4096.0;
+      prolongation[3](19,23) = 15.0/4096.0;
+      prolongation[3](19,24) = -9.0/4096.0;
+      prolongation[3](19,25) = -9.0/4096.0;
+      prolongation[3](19,26) = -9.0/4096.0;
+      prolongation[3](19,27) = -9.0/4096.0;
+      prolongation[3](19,28) = -45.0/4096.0;
+      prolongation[3](19,29) = -45.0/4096.0;
+      prolongation[3](19,30) = -45.0/4096.0;
+      prolongation[3](19,31) = -45.0/4096.0;
+      prolongation[3](19,32) = 45.0/4096.0;
+      prolongation[3](19,33) = 45.0/4096.0;
+      prolongation[3](19,34) = -135.0/4096.0;
+      prolongation[3](19,35) = -135.0/4096.0;
+      prolongation[3](19,36) = 45.0/4096.0;
+      prolongation[3](19,37) = 45.0/4096.0;
+      prolongation[3](19,38) = -135.0/4096.0;
+      prolongation[3](19,39) = -135.0/4096.0;
+      prolongation[3](19,40) = 81.0/4096.0;
+      prolongation[3](19,41) = 81.0/4096.0;
+      prolongation[3](19,42) = 81.0/4096.0;
+      prolongation[3](19,43) = 81.0/4096.0;
+      prolongation[3](19,44) = 45.0/4096.0;
+      prolongation[3](19,45) = 45.0/4096.0;
+      prolongation[3](19,46) = -135.0/4096.0;
+      prolongation[3](19,47) = -135.0/4096.0;
+      prolongation[3](19,48) = 405.0/4096.0;
+      prolongation[3](19,49) = 405.0/4096.0;
+      prolongation[3](19,50) = 405.0/4096.0;
+      prolongation[3](19,51) = 405.0/4096.0;
+      prolongation[3](19,52) = 45.0/4096.0;
+      prolongation[3](19,53) = 45.0/4096.0;
+      prolongation[3](19,54) = -135.0/4096.0;
+      prolongation[3](19,55) = -135.0/4096.0;
+      prolongation[3](19,56) = -405.0/4096.0;
+      prolongation[3](19,57) = -405.0/4096.0;
+      prolongation[3](19,58) = -405.0/4096.0;
+      prolongation[3](19,59) = -405.0/4096.0;
+      prolongation[3](19,60) = 1215.0/4096.0;
+      prolongation[3](19,61) = 1215.0/4096.0;
+      prolongation[3](19,62) = 1215.0/4096.0;
+      prolongation[3](19,63) = 1215.0/4096.0;
+      prolongation[3](20,2) = -1.0/256.0;
+      prolongation[3](20,3) = -5.0/256.0;
+      prolongation[3](20,6) = -1.0/256.0;
+      prolongation[3](20,7) = -5.0/256.0;
+      prolongation[3](20,12) = -15.0/256.0;
+      prolongation[3](20,13) = 5.0/256.0;
+      prolongation[3](20,20) = -15.0/256.0;
+      prolongation[3](20,21) = 5.0/256.0;
+      prolongation[3](20,28) = 9.0/256.0;
+      prolongation[3](20,29) = 9.0/256.0;
+      prolongation[3](20,30) = 45.0/256.0;
+      prolongation[3](20,31) = 45.0/256.0;
+      prolongation[3](20,48) = 135.0/256.0;
+      prolongation[3](20,49) = -45.0/256.0;
+      prolongation[3](20,50) = 135.0/256.0;
+      prolongation[3](20,51) = -45.0/256.0;
+      prolongation[3](21,12) = -1.0/16.0;
+      prolongation[3](21,20) = -1.0/16.0;
+      prolongation[3](21,48) = 9.0/16.0;
+      prolongation[3](21,50) = 9.0/16.0;
+      prolongation[3](22,15) = -1.0/16.0;
+      prolongation[3](22,23) = -1.0/16.0;
+      prolongation[3](22,54) = 9.0/16.0;
+      prolongation[3](22,55) = 9.0/16.0;
+      prolongation[3](23,0) = -1.0/256.0;
+      prolongation[3](23,3) = -5.0/256.0;
+      prolongation[3](23,4) = -1.0/256.0;
+      prolongation[3](23,7) = -5.0/256.0;
+      prolongation[3](23,14) = 5.0/256.0;
+      prolongation[3](23,15) = -15.0/256.0;
+      prolongation[3](23,22) = 5.0/256.0;
+      prolongation[3](23,23) = -15.0/256.0;
+      prolongation[3](23,24) = 9.0/256.0;
+      prolongation[3](23,25) = 9.0/256.0;
+      prolongation[3](23,30) = 45.0/256.0;
+      prolongation[3](23,31) = 45.0/256.0;
+      prolongation[3](23,52) = -45.0/256.0;
+      prolongation[3](23,53) = -45.0/256.0;
+      prolongation[3](23,54) = 135.0/256.0;
+      prolongation[3](23,55) = 135.0/256.0;
+      prolongation[3](24,0) = -5.0/256.0;
+      prolongation[3](24,3) = -5.0/256.0;
+      prolongation[3](24,4) = -1.0/256.0;
+      prolongation[3](24,7) = -1.0/256.0;
+      prolongation[3](24,14) = 45.0/256.0;
+      prolongation[3](24,15) = 45.0/256.0;
+      prolongation[3](24,22) = 9.0/256.0;
+      prolongation[3](24,23) = 9.0/256.0;
+      prolongation[3](24,24) = -15.0/256.0;
+      prolongation[3](24,25) = 5.0/256.0;
+      prolongation[3](24,30) = -15.0/256.0;
+      prolongation[3](24,31) = 5.0/256.0;
+      prolongation[3](24,52) = 135.0/256.0;
+      prolongation[3](24,53) = -45.0/256.0;
+      prolongation[3](24,54) = 135.0/256.0;
+      prolongation[3](24,55) = -45.0/256.0;
+      prolongation[3](25,24) = -1.0/16.0;
+      prolongation[3](25,30) = -1.0/16.0;
+      prolongation[3](25,52) = 9.0/16.0;
+      prolongation[3](25,54) = 9.0/16.0;
+      prolongation[3](26,0) = 5.0/4096.0;
+      prolongation[3](26,1) = 5.0/4096.0;
+      prolongation[3](26,2) = 5.0/4096.0;
+      prolongation[3](26,3) = 5.0/4096.0;
+      prolongation[3](26,4) = 1.0/4096.0;
+      prolongation[3](26,5) = 1.0/4096.0;
+      prolongation[3](26,6) = 1.0/4096.0;
+      prolongation[3](26,7) = 1.0/4096.0;
+      prolongation[3](26,8) = -45.0/4096.0;
+      prolongation[3](26,9) = -45.0/4096.0;
+      prolongation[3](26,10) = -45.0/4096.0;
+      prolongation[3](26,11) = -45.0/4096.0;
+      prolongation[3](26,12) = -45.0/4096.0;
+      prolongation[3](26,13) = -45.0/4096.0;
+      prolongation[3](26,14) = -45.0/4096.0;
+      prolongation[3](26,15) = -45.0/4096.0;
+      prolongation[3](26,16) = -9.0/4096.0;
+      prolongation[3](26,17) = -9.0/4096.0;
+      prolongation[3](26,18) = -9.0/4096.0;
+      prolongation[3](26,19) = -9.0/4096.0;
+      prolongation[3](26,20) = -9.0/4096.0;
+      prolongation[3](26,21) = -9.0/4096.0;
+      prolongation[3](26,22) = -9.0/4096.0;
+      prolongation[3](26,23) = -9.0/4096.0;
+      prolongation[3](26,24) = 15.0/4096.0;
+      prolongation[3](26,25) = -5.0/4096.0;
+      prolongation[3](26,26) = 15.0/4096.0;
+      prolongation[3](26,27) = -5.0/4096.0;
+      prolongation[3](26,28) = 15.0/4096.0;
+      prolongation[3](26,29) = -5.0/4096.0;
+      prolongation[3](26,30) = 15.0/4096.0;
+      prolongation[3](26,31) = -5.0/4096.0;
+      prolongation[3](26,32) = 405.0/4096.0;
+      prolongation[3](26,33) = 405.0/4096.0;
+      prolongation[3](26,34) = 405.0/4096.0;
+      prolongation[3](26,35) = 405.0/4096.0;
+      prolongation[3](26,36) = 81.0/4096.0;
+      prolongation[3](26,37) = 81.0/4096.0;
+      prolongation[3](26,38) = 81.0/4096.0;
+      prolongation[3](26,39) = 81.0/4096.0;
+      prolongation[3](26,40) = -135.0/4096.0;
+      prolongation[3](26,41) = -135.0/4096.0;
+      prolongation[3](26,42) = 45.0/4096.0;
+      prolongation[3](26,43) = 45.0/4096.0;
+      prolongation[3](26,44) = -135.0/4096.0;
+      prolongation[3](26,45) = 45.0/4096.0;
+      prolongation[3](26,46) = -135.0/4096.0;
+      prolongation[3](26,47) = 45.0/4096.0;
+      prolongation[3](26,48) = -135.0/4096.0;
+      prolongation[3](26,49) = -135.0/4096.0;
+      prolongation[3](26,50) = 45.0/4096.0;
+      prolongation[3](26,51) = 45.0/4096.0;
+      prolongation[3](26,52) = -135.0/4096.0;
+      prolongation[3](26,53) = 45.0/4096.0;
+      prolongation[3](26,54) = -135.0/4096.0;
+      prolongation[3](26,55) = 45.0/4096.0;
+      prolongation[3](26,56) = 1215.0/4096.0;
+      prolongation[3](26,57) = 1215.0/4096.0;
+      prolongation[3](26,58) = -405.0/4096.0;
+      prolongation[3](26,59) = -405.0/4096.0;
+      prolongation[3](26,60) = 1215.0/4096.0;
+      prolongation[3](26,61) = 1215.0/4096.0;
+      prolongation[3](26,62) = -405.0/4096.0;
+      prolongation[3](26,63) = -405.0/4096.0;
+      prolongation[3](27,24) = 1.0/256.0;
+      prolongation[3](27,26) = 1.0/256.0;
+      prolongation[3](27,28) = 1.0/256.0;
+      prolongation[3](27,30) = 1.0/256.0;
+      prolongation[3](27,40) = -9.0/256.0;
+      prolongation[3](27,41) = -9.0/256.0;
+      prolongation[3](27,44) = -9.0/256.0;
+      prolongation[3](27,46) = -9.0/256.0;
+      prolongation[3](27,48) = -9.0/256.0;
+      prolongation[3](27,49) = -9.0/256.0;
+      prolongation[3](27,52) = -9.0/256.0;
+      prolongation[3](27,54) = -9.0/256.0;
+      prolongation[3](27,56) = 81.0/256.0;
+      prolongation[3](27,57) = 81.0/256.0;
+      prolongation[3](27,60) = 81.0/256.0;
+      prolongation[3](27,61) = 81.0/256.0;
+      prolongation[3](28,2) = -5.0/256.0;
+      prolongation[3](28,3) = -5.0/256.0;
+      prolongation[3](28,6) = -1.0/256.0;
+      prolongation[3](28,7) = -1.0/256.0;
+      prolongation[3](28,12) = 45.0/256.0;
+      prolongation[3](28,13) = 45.0/256.0;
+      prolongation[3](28,20) = 9.0/256.0;
+      prolongation[3](28,21) = 9.0/256.0;
+      prolongation[3](28,28) = -15.0/256.0;
+      prolongation[3](28,29) = 5.0/256.0;
+      prolongation[3](28,30) = -15.0/256.0;
+      prolongation[3](28,31) = 5.0/256.0;
+      prolongation[3](28,48) = 135.0/256.0;
+      prolongation[3](28,49) = 135.0/256.0;
+      prolongation[3](28,50) = -45.0/256.0;
+      prolongation[3](28,51) = -45.0/256.0;
+      prolongation[3](29,28) = -1.0/16.0;
+      prolongation[3](29,30) = -1.0/16.0;
+      prolongation[3](29,48) = 9.0/16.0;
+      prolongation[3](29,49) = 9.0/16.0;
+      prolongation[3](30,3) = 5.0/16.0;
+      prolongation[3](30,7) = 1.0/16.0;
+      prolongation[3](30,30) = 15.0/16.0;
+      prolongation[3](30,31) = -5.0/16.0;
+      prolongation[3](31,30) = 1.0;
+      prolongation[3](32,11) = 1.0/16.0;
+      prolongation[3](32,15) = 5.0/16.0;
+      prolongation[3](32,34) = 15.0/16.0;
+      prolongation[3](32,35) = -5.0/16.0;
+      prolongation[3](33,34) = 1.0;
+      prolongation[3](34,0) = 5.0/256.0;
+      prolongation[3](34,1) = 1.0/256.0;
+      prolongation[3](34,2) = 5.0/256.0;
+      prolongation[3](34,3) = 25.0/256.0;
+      prolongation[3](34,8) = 15.0/256.0;
+      prolongation[3](34,9) = -5.0/256.0;
+      prolongation[3](34,10) = -5.0/256.0;
+      prolongation[3](34,11) = 15.0/256.0;
+      prolongation[3](34,12) = 75.0/256.0;
+      prolongation[3](34,13) = -25.0/256.0;
+      prolongation[3](34,14) = -25.0/256.0;
+      prolongation[3](34,15) = 75.0/256.0;
+      prolongation[3](34,32) = -75.0/256.0;
+      prolongation[3](34,33) = 25.0/256.0;
+      prolongation[3](34,34) = 225.0/256.0;
+      prolongation[3](34,35) = -75.0/256.0;
+      prolongation[3](35,8) = 1.0/16.0;
+      prolongation[3](35,12) = 5.0/16.0;
+      prolongation[3](35,32) = -5.0/16.0;
+      prolongation[3](35,34) = 15.0/16.0;
+      prolongation[3](36,11) = -1.0/256.0;
+      prolongation[3](36,15) = -5.0/256.0;
+      prolongation[3](36,19) = -1.0/256.0;
+      prolongation[3](36,23) = -5.0/256.0;
+      prolongation[3](36,34) = -15.0/256.0;
+      prolongation[3](36,35) = 5.0/256.0;
+      prolongation[3](36,38) = -15.0/256.0;
+      prolongation[3](36,39) = 5.0/256.0;
+      prolongation[3](36,46) = 9.0/256.0;
+      prolongation[3](36,47) = 9.0/256.0;
+      prolongation[3](36,54) = 45.0/256.0;
+      prolongation[3](36,55) = 45.0/256.0;
+      prolongation[3](36,60) = 135.0/256.0;
+      prolongation[3](36,61) = -45.0/256.0;
+      prolongation[3](36,62) = 135.0/256.0;
+      prolongation[3](36,63) = -45.0/256.0;
+      prolongation[3](37,34) = -1.0/16.0;
+      prolongation[3](37,38) = -1.0/16.0;
+      prolongation[3](37,60) = 9.0/16.0;
+      prolongation[3](37,62) = 9.0/16.0;
+      prolongation[3](38,0) = -5.0/4096.0;
+      prolongation[3](38,1) = -1.0/4096.0;
+      prolongation[3](38,2) = -5.0/4096.0;
+      prolongation[3](38,3) = -25.0/4096.0;
+      prolongation[3](38,4) = -5.0/4096.0;
+      prolongation[3](38,5) = -1.0/4096.0;
+      prolongation[3](38,6) = -5.0/4096.0;
+      prolongation[3](38,7) = -25.0/4096.0;
+      prolongation[3](38,8) = -15.0/4096.0;
+      prolongation[3](38,9) = 5.0/4096.0;
+      prolongation[3](38,10) = 5.0/4096.0;
+      prolongation[3](38,11) = -15.0/4096.0;
+      prolongation[3](38,12) = -75.0/4096.0;
+      prolongation[3](38,13) = 25.0/4096.0;
+      prolongation[3](38,14) = 25.0/4096.0;
+      prolongation[3](38,15) = -75.0/4096.0;
+      prolongation[3](38,16) = -15.0/4096.0;
+      prolongation[3](38,17) = 5.0/4096.0;
+      prolongation[3](38,18) = 5.0/4096.0;
+      prolongation[3](38,19) = -15.0/4096.0;
+      prolongation[3](38,20) = -75.0/4096.0;
+      prolongation[3](38,21) = 25.0/4096.0;
+      prolongation[3](38,22) = 25.0/4096.0;
+      prolongation[3](38,23) = -75.0/4096.0;
+      prolongation[3](38,24) = 45.0/4096.0;
+      prolongation[3](38,25) = 45.0/4096.0;
+      prolongation[3](38,26) = 9.0/4096.0;
+      prolongation[3](38,27) = 9.0/4096.0;
+      prolongation[3](38,28) = 45.0/4096.0;
+      prolongation[3](38,29) = 45.0/4096.0;
+      prolongation[3](38,30) = 225.0/4096.0;
+      prolongation[3](38,31) = 225.0/4096.0;
+      prolongation[3](38,32) = 75.0/4096.0;
+      prolongation[3](38,33) = -25.0/4096.0;
+      prolongation[3](38,34) = -225.0/4096.0;
+      prolongation[3](38,35) = 75.0/4096.0;
+      prolongation[3](38,36) = 75.0/4096.0;
+      prolongation[3](38,37) = -25.0/4096.0;
+      prolongation[3](38,38) = -225.0/4096.0;
+      prolongation[3](38,39) = 75.0/4096.0;
+      prolongation[3](38,40) = 135.0/4096.0;
+      prolongation[3](38,41) = -45.0/4096.0;
+      prolongation[3](38,42) = 135.0/4096.0;
+      prolongation[3](38,43) = -45.0/4096.0;
+      prolongation[3](38,44) = -45.0/4096.0;
+      prolongation[3](38,45) = -45.0/4096.0;
+      prolongation[3](38,46) = 135.0/4096.0;
+      prolongation[3](38,47) = 135.0/4096.0;
+      prolongation[3](38,48) = 675.0/4096.0;
+      prolongation[3](38,49) = -225.0/4096.0;
+      prolongation[3](38,50) = 675.0/4096.0;
+      prolongation[3](38,51) = -225.0/4096.0;
+      prolongation[3](38,52) = -225.0/4096.0;
+      prolongation[3](38,53) = -225.0/4096.0;
+      prolongation[3](38,54) = 675.0/4096.0;
+      prolongation[3](38,55) = 675.0/4096.0;
+      prolongation[3](38,56) = -675.0/4096.0;
+      prolongation[3](38,57) = 225.0/4096.0;
+      prolongation[3](38,58) = -675.0/4096.0;
+      prolongation[3](38,59) = 225.0/4096.0;
+      prolongation[3](38,60) = 2025.0/4096.0;
+      prolongation[3](38,61) = -675.0/4096.0;
+      prolongation[3](38,62) = 2025.0/4096.0;
+      prolongation[3](38,63) = -675.0/4096.0;
+      prolongation[3](39,8) = -1.0/256.0;
+      prolongation[3](39,12) = -5.0/256.0;
+      prolongation[3](39,16) = -1.0/256.0;
+      prolongation[3](39,20) = -5.0/256.0;
+      prolongation[3](39,32) = 5.0/256.0;
+      prolongation[3](39,34) = -15.0/256.0;
+      prolongation[3](39,36) = 5.0/256.0;
+      prolongation[3](39,38) = -15.0/256.0;
+      prolongation[3](39,40) = 9.0/256.0;
+      prolongation[3](39,42) = 9.0/256.0;
+      prolongation[3](39,48) = 45.0/256.0;
+      prolongation[3](39,50) = 45.0/256.0;
+      prolongation[3](39,56) = -45.0/256.0;
+      prolongation[3](39,58) = -45.0/256.0;
+      prolongation[3](39,60) = 135.0/256.0;
+      prolongation[3](39,62) = 135.0/256.0;
+      prolongation[3](40,0) = -25.0/4096.0;
+      prolongation[3](40,1) = -5.0/4096.0;
+      prolongation[3](40,2) = -5.0/4096.0;
+      prolongation[3](40,3) = -25.0/4096.0;
+      prolongation[3](40,4) = -5.0/4096.0;
+      prolongation[3](40,5) = -1.0/4096.0;
+      prolongation[3](40,6) = -1.0/4096.0;
+      prolongation[3](40,7) = -5.0/4096.0;
+      prolongation[3](40,8) = -75.0/4096.0;
+      prolongation[3](40,9) = 25.0/4096.0;
+      prolongation[3](40,10) = 45.0/4096.0;
+      prolongation[3](40,11) = 45.0/4096.0;
+      prolongation[3](40,12) = -75.0/4096.0;
+      prolongation[3](40,13) = 25.0/4096.0;
+      prolongation[3](40,14) = 225.0/4096.0;
+      prolongation[3](40,15) = 225.0/4096.0;
+      prolongation[3](40,16) = -15.0/4096.0;
+      prolongation[3](40,17) = 5.0/4096.0;
+      prolongation[3](40,18) = 9.0/4096.0;
+      prolongation[3](40,19) = 9.0/4096.0;
+      prolongation[3](40,20) = -15.0/4096.0;
+      prolongation[3](40,21) = 5.0/4096.0;
+      prolongation[3](40,22) = 45.0/4096.0;
+      prolongation[3](40,23) = 45.0/4096.0;
+      prolongation[3](40,24) = -75.0/4096.0;
+      prolongation[3](40,25) = 25.0/4096.0;
+      prolongation[3](40,26) = -15.0/4096.0;
+      prolongation[3](40,27) = 5.0/4096.0;
+      prolongation[3](40,28) = -15.0/4096.0;
+      prolongation[3](40,29) = 5.0/4096.0;
+      prolongation[3](40,30) = -75.0/4096.0;
+      prolongation[3](40,31) = 25.0/4096.0;
+      prolongation[3](40,32) = 675.0/4096.0;
+      prolongation[3](40,33) = -225.0/4096.0;
+      prolongation[3](40,34) = 675.0/4096.0;
+      prolongation[3](40,35) = -225.0/4096.0;
+      prolongation[3](40,36) = 135.0/4096.0;
+      prolongation[3](40,37) = -45.0/4096.0;
+      prolongation[3](40,38) = 135.0/4096.0;
+      prolongation[3](40,39) = -45.0/4096.0;
+      prolongation[3](40,40) = -225.0/4096.0;
+      prolongation[3](40,41) = 75.0/4096.0;
+      prolongation[3](40,42) = 75.0/4096.0;
+      prolongation[3](40,43) = -25.0/4096.0;
+      prolongation[3](40,44) = 135.0/4096.0;
+      prolongation[3](40,45) = -45.0/4096.0;
+      prolongation[3](40,46) = 135.0/4096.0;
+      prolongation[3](40,47) = -45.0/4096.0;
+      prolongation[3](40,48) = -225.0/4096.0;
+      prolongation[3](40,49) = 75.0/4096.0;
+      prolongation[3](40,50) = 75.0/4096.0;
+      prolongation[3](40,51) = -25.0/4096.0;
+      prolongation[3](40,52) = 675.0/4096.0;
+      prolongation[3](40,53) = -225.0/4096.0;
+      prolongation[3](40,54) = 675.0/4096.0;
+      prolongation[3](40,55) = -225.0/4096.0;
+      prolongation[3](40,56) = 2025.0/4096.0;
+      prolongation[3](40,57) = -675.0/4096.0;
+      prolongation[3](40,58) = -675.0/4096.0;
+      prolongation[3](40,59) = 225.0/4096.0;
+      prolongation[3](40,60) = 2025.0/4096.0;
+      prolongation[3](40,61) = -675.0/4096.0;
+      prolongation[3](40,62) = -675.0/4096.0;
+      prolongation[3](40,63) = 225.0/4096.0;
+      prolongation[3](41,8) = -5.0/256.0;
+      prolongation[3](41,12) = -5.0/256.0;
+      prolongation[3](41,16) = -1.0/256.0;
+      prolongation[3](41,20) = -1.0/256.0;
+      prolongation[3](41,32) = 45.0/256.0;
+      prolongation[3](41,34) = 45.0/256.0;
+      prolongation[3](41,36) = 9.0/256.0;
+      prolongation[3](41,38) = 9.0/256.0;
+      prolongation[3](41,40) = -15.0/256.0;
+      prolongation[3](41,42) = 5.0/256.0;
+      prolongation[3](41,48) = -15.0/256.0;
+      prolongation[3](41,50) = 5.0/256.0;
+      prolongation[3](41,56) = 135.0/256.0;
+      prolongation[3](41,58) = -45.0/256.0;
+      prolongation[3](41,60) = 135.0/256.0;
+      prolongation[3](41,62) = -45.0/256.0;
+      prolongation[3](42,24) = -5.0/256.0;
+      prolongation[3](42,26) = -1.0/256.0;
+      prolongation[3](42,28) = -1.0/256.0;
+      prolongation[3](42,30) = -5.0/256.0;
+      prolongation[3](42,40) = -15.0/256.0;
+      prolongation[3](42,41) = 5.0/256.0;
+      prolongation[3](42,44) = 9.0/256.0;
+      prolongation[3](42,46) = 9.0/256.0;
+      prolongation[3](42,48) = -15.0/256.0;
+      prolongation[3](42,49) = 5.0/256.0;
+      prolongation[3](42,52) = 45.0/256.0;
+      prolongation[3](42,54) = 45.0/256.0;
+      prolongation[3](42,56) = 135.0/256.0;
+      prolongation[3](42,57) = -45.0/256.0;
+      prolongation[3](42,60) = 135.0/256.0;
+      prolongation[3](42,61) = -45.0/256.0;
+      prolongation[3](43,40) = -1.0/16.0;
+      prolongation[3](43,48) = -1.0/16.0;
+      prolongation[3](43,56) = 9.0/16.0;
+      prolongation[3](43,60) = 9.0/16.0;
+      prolongation[3](44,11) = -5.0/256.0;
+      prolongation[3](44,15) = -5.0/256.0;
+      prolongation[3](44,19) = -1.0/256.0;
+      prolongation[3](44,23) = -1.0/256.0;
+      prolongation[3](44,34) = 45.0/256.0;
+      prolongation[3](44,35) = 45.0/256.0;
+      prolongation[3](44,38) = 9.0/256.0;
+      prolongation[3](44,39) = 9.0/256.0;
+      prolongation[3](44,46) = -15.0/256.0;
+      prolongation[3](44,47) = 5.0/256.0;
+      prolongation[3](44,54) = -15.0/256.0;
+      prolongation[3](44,55) = 5.0/256.0;
+      prolongation[3](44,60) = 135.0/256.0;
+      prolongation[3](44,61) = 135.0/256.0;
+      prolongation[3](44,62) = -45.0/256.0;
+      prolongation[3](44,63) = -45.0/256.0;
+      prolongation[3](45,46) = -1.0/16.0;
+      prolongation[3](45,54) = -1.0/16.0;
+      prolongation[3](45,60) = 9.0/16.0;
+      prolongation[3](45,61) = 9.0/16.0;
+      prolongation[3](46,0) = -5.0/4096.0;
+      prolongation[3](46,1) = -5.0/4096.0;
+      prolongation[3](46,2) = -25.0/4096.0;
+      prolongation[3](46,3) = -25.0/4096.0;
+      prolongation[3](46,4) = -1.0/4096.0;
+      prolongation[3](46,5) = -1.0/4096.0;
+      prolongation[3](46,6) = -5.0/4096.0;
+      prolongation[3](46,7) = -5.0/4096.0;
+      prolongation[3](46,8) = 45.0/4096.0;
+      prolongation[3](46,9) = 45.0/4096.0;
+      prolongation[3](46,10) = 25.0/4096.0;
+      prolongation[3](46,11) = -75.0/4096.0;
+      prolongation[3](46,12) = 225.0/4096.0;
+      prolongation[3](46,13) = 225.0/4096.0;
+      prolongation[3](46,14) = 25.0/4096.0;
+      prolongation[3](46,15) = -75.0/4096.0;
+      prolongation[3](46,16) = 9.0/4096.0;
+      prolongation[3](46,17) = 9.0/4096.0;
+      prolongation[3](46,18) = 5.0/4096.0;
+      prolongation[3](46,19) = -15.0/4096.0;
+      prolongation[3](46,20) = 45.0/4096.0;
+      prolongation[3](46,21) = 45.0/4096.0;
+      prolongation[3](46,22) = 5.0/4096.0;
+      prolongation[3](46,23) = -15.0/4096.0;
+      prolongation[3](46,24) = -15.0/4096.0;
+      prolongation[3](46,25) = 5.0/4096.0;
+      prolongation[3](46,26) = -15.0/4096.0;
+      prolongation[3](46,27) = 5.0/4096.0;
+      prolongation[3](46,28) = -75.0/4096.0;
+      prolongation[3](46,29) = 25.0/4096.0;
+      prolongation[3](46,30) = -75.0/4096.0;
+      prolongation[3](46,31) = 25.0/4096.0;
+      prolongation[3](46,32) = -225.0/4096.0;
+      prolongation[3](46,33) = -225.0/4096.0;
+      prolongation[3](46,34) = 675.0/4096.0;
+      prolongation[3](46,35) = 675.0/4096.0;
+      prolongation[3](46,36) = -45.0/4096.0;
+      prolongation[3](46,37) = -45.0/4096.0;
+      prolongation[3](46,38) = 135.0/4096.0;
+      prolongation[3](46,39) = 135.0/4096.0;
+      prolongation[3](46,40) = 135.0/4096.0;
+      prolongation[3](46,41) = 135.0/4096.0;
+      prolongation[3](46,42) = -45.0/4096.0;
+      prolongation[3](46,43) = -45.0/4096.0;
+      prolongation[3](46,44) = 75.0/4096.0;
+      prolongation[3](46,45) = -25.0/4096.0;
+      prolongation[3](46,46) = -225.0/4096.0;
+      prolongation[3](46,47) = 75.0/4096.0;
+      prolongation[3](46,48) = 675.0/4096.0;
+      prolongation[3](46,49) = 675.0/4096.0;
+      prolongation[3](46,50) = -225.0/4096.0;
+      prolongation[3](46,51) = -225.0/4096.0;
+      prolongation[3](46,52) = 75.0/4096.0;
+      prolongation[3](46,53) = -25.0/4096.0;
+      prolongation[3](46,54) = -225.0/4096.0;
+      prolongation[3](46,55) = 75.0/4096.0;
+      prolongation[3](46,56) = -675.0/4096.0;
+      prolongation[3](46,57) = -675.0/4096.0;
+      prolongation[3](46,58) = 225.0/4096.0;
+      prolongation[3](46,59) = 225.0/4096.0;
+      prolongation[3](46,60) = 2025.0/4096.0;
+      prolongation[3](46,61) = 2025.0/4096.0;
+      prolongation[3](46,62) = -675.0/4096.0;
+      prolongation[3](46,63) = -675.0/4096.0;
+      prolongation[3](47,24) = -1.0/256.0;
+      prolongation[3](47,26) = -1.0/256.0;
+      prolongation[3](47,28) = -5.0/256.0;
+      prolongation[3](47,30) = -5.0/256.0;
+      prolongation[3](47,40) = 9.0/256.0;
+      prolongation[3](47,41) = 9.0/256.0;
+      prolongation[3](47,44) = 5.0/256.0;
+      prolongation[3](47,46) = -15.0/256.0;
+      prolongation[3](47,48) = 45.0/256.0;
+      prolongation[3](47,49) = 45.0/256.0;
+      prolongation[3](47,52) = 5.0/256.0;
+      prolongation[3](47,54) = -15.0/256.0;
+      prolongation[3](47,56) = -45.0/256.0;
+      prolongation[3](47,57) = -45.0/256.0;
+      prolongation[3](47,60) = 135.0/256.0;
+      prolongation[3](47,61) = 135.0/256.0;
+      prolongation[3](48,2) = 5.0/256.0;
+      prolongation[3](48,3) = 25.0/256.0;
+      prolongation[3](48,6) = 1.0/256.0;
+      prolongation[3](48,7) = 5.0/256.0;
+      prolongation[3](48,12) = 75.0/256.0;
+      prolongation[3](48,13) = -25.0/256.0;
+      prolongation[3](48,20) = 15.0/256.0;
+      prolongation[3](48,21) = -5.0/256.0;
+      prolongation[3](48,28) = 15.0/256.0;
+      prolongation[3](48,29) = -5.0/256.0;
+      prolongation[3](48,30) = 75.0/256.0;
+      prolongation[3](48,31) = -25.0/256.0;
+      prolongation[3](48,48) = 225.0/256.0;
+      prolongation[3](48,49) = -75.0/256.0;
+      prolongation[3](48,50) = -75.0/256.0;
+      prolongation[3](48,51) = 25.0/256.0;
+      prolongation[3](49,12) = 5.0/16.0;
+      prolongation[3](49,20) = 1.0/16.0;
+      prolongation[3](49,48) = 15.0/16.0;
+      prolongation[3](49,50) = -5.0/16.0;
+      prolongation[3](50,28) = 1.0/16.0;
+      prolongation[3](50,30) = 5.0/16.0;
+      prolongation[3](50,48) = 15.0/16.0;
+      prolongation[3](50,49) = -5.0/16.0;
+      prolongation[3](51,48) = 1.0;
+      prolongation[3](52,15) = 5.0/16.0;
+      prolongation[3](52,23) = 1.0/16.0;
+      prolongation[3](52,54) = 15.0/16.0;
+      prolongation[3](52,55) = -5.0/16.0;
+      prolongation[3](53,54) = 1.0;
+      prolongation[3](54,0) = 5.0/256.0;
+      prolongation[3](54,3) = 25.0/256.0;
+      prolongation[3](54,4) = 1.0/256.0;
+      prolongation[3](54,7) = 5.0/256.0;
+      prolongation[3](54,14) = -25.0/256.0;
+      prolongation[3](54,15) = 75.0/256.0;
+      prolongation[3](54,22) = -5.0/256.0;
+      prolongation[3](54,23) = 15.0/256.0;
+      prolongation[3](54,24) = 15.0/256.0;
+      prolongation[3](54,25) = -5.0/256.0;
+      prolongation[3](54,30) = 75.0/256.0;
+      prolongation[3](54,31) = -25.0/256.0;
+      prolongation[3](54,52) = -75.0/256.0;
+      prolongation[3](54,53) = 25.0/256.0;
+      prolongation[3](54,54) = 225.0/256.0;
+      prolongation[3](54,55) = -75.0/256.0;
+      prolongation[3](55,24) = 1.0/16.0;
+      prolongation[3](55,30) = 5.0/16.0;
+      prolongation[3](55,52) = -5.0/16.0;
+      prolongation[3](55,54) = 15.0/16.0;
+      prolongation[3](56,11) = 5.0/256.0;
+      prolongation[3](56,15) = 25.0/256.0;
+      prolongation[3](56,19) = 1.0/256.0;
+      prolongation[3](56,23) = 5.0/256.0;
+      prolongation[3](56,34) = 75.0/256.0;
+      prolongation[3](56,35) = -25.0/256.0;
+      prolongation[3](56,38) = 15.0/256.0;
+      prolongation[3](56,39) = -5.0/256.0;
+      prolongation[3](56,46) = 15.0/256.0;
+      prolongation[3](56,47) = -5.0/256.0;
+      prolongation[3](56,54) = 75.0/256.0;
+      prolongation[3](56,55) = -25.0/256.0;
+      prolongation[3](56,60) = 225.0/256.0;
+      prolongation[3](56,61) = -75.0/256.0;
+      prolongation[3](56,62) = -75.0/256.0;
+      prolongation[3](56,63) = 25.0/256.0;
+      prolongation[3](57,34) = 5.0/16.0;
+      prolongation[3](57,38) = 1.0/16.0;
+      prolongation[3](57,60) = 15.0/16.0;
+      prolongation[3](57,62) = -5.0/16.0;
+      prolongation[3](58,46) = 1.0/16.0;
+      prolongation[3](58,54) = 5.0/16.0;
+      prolongation[3](58,60) = 15.0/16.0;
+      prolongation[3](58,61) = -5.0/16.0;
+      prolongation[3](59,60) = 1.0;
+      prolongation[3](60,0) = 25.0/4096.0;
+      prolongation[3](60,1) = 5.0/4096.0;
+      prolongation[3](60,2) = 25.0/4096.0;
+      prolongation[3](60,3) = 125.0/4096.0;
+      prolongation[3](60,4) = 5.0/4096.0;
+      prolongation[3](60,5) = 1.0/4096.0;
+      prolongation[3](60,6) = 5.0/4096.0;
+      prolongation[3](60,7) = 25.0/4096.0;
+      prolongation[3](60,8) = 75.0/4096.0;
+      prolongation[3](60,9) = -25.0/4096.0;
+      prolongation[3](60,10) = -25.0/4096.0;
+      prolongation[3](60,11) = 75.0/4096.0;
+      prolongation[3](60,12) = 375.0/4096.0;
+      prolongation[3](60,13) = -125.0/4096.0;
+      prolongation[3](60,14) = -125.0/4096.0;
+      prolongation[3](60,15) = 375.0/4096.0;
+      prolongation[3](60,16) = 15.0/4096.0;
+      prolongation[3](60,17) = -5.0/4096.0;
+      prolongation[3](60,18) = -5.0/4096.0;
+      prolongation[3](60,19) = 15.0/4096.0;
+      prolongation[3](60,20) = 75.0/4096.0;
+      prolongation[3](60,21) = -25.0/4096.0;
+      prolongation[3](60,22) = -25.0/4096.0;
+      prolongation[3](60,23) = 75.0/4096.0;
+      prolongation[3](60,24) = 75.0/4096.0;
+      prolongation[3](60,25) = -25.0/4096.0;
+      prolongation[3](60,26) = 15.0/4096.0;
+      prolongation[3](60,27) = -5.0/4096.0;
+      prolongation[3](60,28) = 75.0/4096.0;
+      prolongation[3](60,29) = -25.0/4096.0;
+      prolongation[3](60,30) = 375.0/4096.0;
+      prolongation[3](60,31) = -125.0/4096.0;
+      prolongation[3](60,32) = -375.0/4096.0;
+      prolongation[3](60,33) = 125.0/4096.0;
+      prolongation[3](60,34) = 1125.0/4096.0;
+      prolongation[3](60,35) = -375.0/4096.0;
+      prolongation[3](60,36) = -75.0/4096.0;
+      prolongation[3](60,37) = 25.0/4096.0;
+      prolongation[3](60,38) = 225.0/4096.0;
+      prolongation[3](60,39) = -75.0/4096.0;
+      prolongation[3](60,40) = 225.0/4096.0;
+      prolongation[3](60,41) = -75.0/4096.0;
+      prolongation[3](60,42) = -75.0/4096.0;
+      prolongation[3](60,43) = 25.0/4096.0;
+      prolongation[3](60,44) = -75.0/4096.0;
+      prolongation[3](60,45) = 25.0/4096.0;
+      prolongation[3](60,46) = 225.0/4096.0;
+      prolongation[3](60,47) = -75.0/4096.0;
+      prolongation[3](60,48) = 1125.0/4096.0;
+      prolongation[3](60,49) = -375.0/4096.0;
+      prolongation[3](60,50) = -375.0/4096.0;
+      prolongation[3](60,51) = 125.0/4096.0;
+      prolongation[3](60,52) = -375.0/4096.0;
+      prolongation[3](60,53) = 125.0/4096.0;
+      prolongation[3](60,54) = 1125.0/4096.0;
+      prolongation[3](60,55) = -375.0/4096.0;
+      prolongation[3](60,56) = -1125.0/4096.0;
+      prolongation[3](60,57) = 375.0/4096.0;
+      prolongation[3](60,58) = 375.0/4096.0;
+      prolongation[3](60,59) = -125.0/4096.0;
+      prolongation[3](60,60) = 3375.0/4096.0;
+      prolongation[3](60,61) = -1125.0/4096.0;
+      prolongation[3](60,62) = -1125.0/4096.0;
+      prolongation[3](60,63) = 375.0/4096.0;
+      prolongation[3](61,8) = 5.0/256.0;
+      prolongation[3](61,12) = 25.0/256.0;
+      prolongation[3](61,16) = 1.0/256.0;
+      prolongation[3](61,20) = 5.0/256.0;
+      prolongation[3](61,32) = -25.0/256.0;
+      prolongation[3](61,34) = 75.0/256.0;
+      prolongation[3](61,36) = -5.0/256.0;
+      prolongation[3](61,38) = 15.0/256.0;
+      prolongation[3](61,40) = 15.0/256.0;
+      prolongation[3](61,42) = -5.0/256.0;
+      prolongation[3](61,48) = 75.0/256.0;
+      prolongation[3](61,50) = -25.0/256.0;
+      prolongation[3](61,56) = -75.0/256.0;
+      prolongation[3](61,58) = 25.0/256.0;
+      prolongation[3](61,60) = 225.0/256.0;
+      prolongation[3](61,62) = -75.0/256.0;
+      prolongation[3](62,24) = 5.0/256.0;
+      prolongation[3](62,26) = 1.0/256.0;
+      prolongation[3](62,28) = 5.0/256.0;
+      prolongation[3](62,30) = 25.0/256.0;
+      prolongation[3](62,40) = 15.0/256.0;
+      prolongation[3](62,41) = -5.0/256.0;
+      prolongation[3](62,44) = -5.0/256.0;
+      prolongation[3](62,46) = 15.0/256.0;
+      prolongation[3](62,48) = 75.0/256.0;
+      prolongation[3](62,49) = -25.0/256.0;
+      prolongation[3](62,52) = -25.0/256.0;
+      prolongation[3](62,54) = 75.0/256.0;
+      prolongation[3](62,56) = -75.0/256.0;
+      prolongation[3](62,57) = 25.0/256.0;
+      prolongation[3](62,60) = 225.0/256.0;
+      prolongation[3](62,61) = -75.0/256.0;
+      prolongation[3](63,40) = 1.0/16.0;
+      prolongation[3](63,48) = 5.0/16.0;
+      prolongation[3](63,56) = -5.0/16.0;
+      prolongation[3](63,60) = 15.0/16.0;
+      prolongation[4](0,0) = -1.0/16.0;
+      prolongation[4](0,4) = -1.0/16.0;
+      prolongation[4](0,24) = 9.0/16.0;
+      prolongation[4](0,25) = 9.0/16.0;
+      prolongation[4](1,0) = 1.0/256.0;
+      prolongation[4](1,1) = 1.0/256.0;
+      prolongation[4](1,4) = 1.0/256.0;
+      prolongation[4](1,5) = 1.0/256.0;
+      prolongation[4](1,8) = -9.0/256.0;
+      prolongation[4](1,9) = -9.0/256.0;
+      prolongation[4](1,16) = -9.0/256.0;
+      prolongation[4](1,17) = -9.0/256.0;
+      prolongation[4](1,24) = -9.0/256.0;
+      prolongation[4](1,25) = -9.0/256.0;
+      prolongation[4](1,26) = -9.0/256.0;
+      prolongation[4](1,27) = -9.0/256.0;
+      prolongation[4](1,40) = 81.0/256.0;
+      prolongation[4](1,41) = 81.0/256.0;
+      prolongation[4](1,42) = 81.0/256.0;
+      prolongation[4](1,43) = 81.0/256.0;
+      prolongation[4](2,0) = -1.0/4096.0;
+      prolongation[4](2,1) = -1.0/4096.0;
+      prolongation[4](2,2) = -1.0/4096.0;
+      prolongation[4](2,3) = -1.0/4096.0;
+      prolongation[4](2,4) = -1.0/4096.0;
+      prolongation[4](2,5) = -1.0/4096.0;
+      prolongation[4](2,6) = -1.0/4096.0;
+      prolongation[4](2,7) = -1.0/4096.0;
+      prolongation[4](2,8) = 9.0/4096.0;
+      prolongation[4](2,9) = 9.0/4096.0;
+      prolongation[4](2,10) = 9.0/4096.0;
+      prolongation[4](2,11) = 9.0/4096.0;
+      prolongation[4](2,12) = 9.0/4096.0;
+      prolongation[4](2,13) = 9.0/4096.0;
+      prolongation[4](2,14) = 9.0/4096.0;
+      prolongation[4](2,15) = 9.0/4096.0;
+      prolongation[4](2,16) = 9.0/4096.0;
+      prolongation[4](2,17) = 9.0/4096.0;
+      prolongation[4](2,18) = 9.0/4096.0;
+      prolongation[4](2,19) = 9.0/4096.0;
+      prolongation[4](2,20) = 9.0/4096.0;
+      prolongation[4](2,21) = 9.0/4096.0;
+      prolongation[4](2,22) = 9.0/4096.0;
+      prolongation[4](2,23) = 9.0/4096.0;
+      prolongation[4](2,24) = 9.0/4096.0;
+      prolongation[4](2,25) = 9.0/4096.0;
+      prolongation[4](2,26) = 9.0/4096.0;
+      prolongation[4](2,27) = 9.0/4096.0;
+      prolongation[4](2,28) = 9.0/4096.0;
+      prolongation[4](2,29) = 9.0/4096.0;
+      prolongation[4](2,30) = 9.0/4096.0;
+      prolongation[4](2,31) = 9.0/4096.0;
+      prolongation[4](2,32) = -81.0/4096.0;
+      prolongation[4](2,33) = -81.0/4096.0;
+      prolongation[4](2,34) = -81.0/4096.0;
+      prolongation[4](2,35) = -81.0/4096.0;
+      prolongation[4](2,36) = -81.0/4096.0;
+      prolongation[4](2,37) = -81.0/4096.0;
+      prolongation[4](2,38) = -81.0/4096.0;
+      prolongation[4](2,39) = -81.0/4096.0;
+      prolongation[4](2,40) = -81.0/4096.0;
+      prolongation[4](2,41) = -81.0/4096.0;
+      prolongation[4](2,42) = -81.0/4096.0;
+      prolongation[4](2,43) = -81.0/4096.0;
+      prolongation[4](2,44) = -81.0/4096.0;
+      prolongation[4](2,45) = -81.0/4096.0;
+      prolongation[4](2,46) = -81.0/4096.0;
+      prolongation[4](2,47) = -81.0/4096.0;
+      prolongation[4](2,48) = -81.0/4096.0;
+      prolongation[4](2,49) = -81.0/4096.0;
+      prolongation[4](2,50) = -81.0/4096.0;
+      prolongation[4](2,51) = -81.0/4096.0;
+      prolongation[4](2,52) = -81.0/4096.0;
+      prolongation[4](2,53) = -81.0/4096.0;
+      prolongation[4](2,54) = -81.0/4096.0;
+      prolongation[4](2,55) = -81.0/4096.0;
+      prolongation[4](2,56) = 729.0/4096.0;
+      prolongation[4](2,57) = 729.0/4096.0;
+      prolongation[4](2,58) = 729.0/4096.0;
+      prolongation[4](2,59) = 729.0/4096.0;
+      prolongation[4](2,60) = 729.0/4096.0;
+      prolongation[4](2,61) = 729.0/4096.0;
+      prolongation[4](2,62) = 729.0/4096.0;
+      prolongation[4](2,63) = 729.0/4096.0;
+      prolongation[4](3,0) = 1.0/256.0;
+      prolongation[4](3,3) = 1.0/256.0;
+      prolongation[4](3,4) = 1.0/256.0;
+      prolongation[4](3,7) = 1.0/256.0;
+      prolongation[4](3,14) = -9.0/256.0;
+      prolongation[4](3,15) = -9.0/256.0;
+      prolongation[4](3,22) = -9.0/256.0;
+      prolongation[4](3,23) = -9.0/256.0;
+      prolongation[4](3,24) = -9.0/256.0;
+      prolongation[4](3,25) = -9.0/256.0;
+      prolongation[4](3,30) = -9.0/256.0;
+      prolongation[4](3,31) = -9.0/256.0;
+      prolongation[4](3,52) = 81.0/256.0;
+      prolongation[4](3,53) = 81.0/256.0;
+      prolongation[4](3,54) = 81.0/256.0;
+      prolongation[4](3,55) = 81.0/256.0;
+      prolongation[4](4,4) = 1.0;
+      prolongation[4](5,4) = -1.0/16.0;
+      prolongation[4](5,5) = -1.0/16.0;
+      prolongation[4](5,16) = 9.0/16.0;
+      prolongation[4](5,17) = 9.0/16.0;
+      prolongation[4](6,4) = 1.0/256.0;
+      prolongation[4](6,5) = 1.0/256.0;
+      prolongation[4](6,6) = 1.0/256.0;
+      prolongation[4](6,7) = 1.0/256.0;
+      prolongation[4](6,16) = -9.0/256.0;
+      prolongation[4](6,17) = -9.0/256.0;
+      prolongation[4](6,18) = -9.0/256.0;
+      prolongation[4](6,19) = -9.0/256.0;
+      prolongation[4](6,20) = -9.0/256.0;
+      prolongation[4](6,21) = -9.0/256.0;
+      prolongation[4](6,22) = -9.0/256.0;
+      prolongation[4](6,23) = -9.0/256.0;
+      prolongation[4](6,36) = 81.0/256.0;
+      prolongation[4](6,37) = 81.0/256.0;
+      prolongation[4](6,38) = 81.0/256.0;
+      prolongation[4](6,39) = 81.0/256.0;
+      prolongation[4](7,4) = -1.0/16.0;
+      prolongation[4](7,7) = -1.0/16.0;
+      prolongation[4](7,22) = 9.0/16.0;
+      prolongation[4](7,23) = 9.0/16.0;
+      prolongation[4](8,0) = -5.0/256.0;
+      prolongation[4](8,1) = -1.0/256.0;
+      prolongation[4](8,4) = -5.0/256.0;
+      prolongation[4](8,5) = -1.0/256.0;
+      prolongation[4](8,8) = -15.0/256.0;
+      prolongation[4](8,9) = 5.0/256.0;
+      prolongation[4](8,16) = -15.0/256.0;
+      prolongation[4](8,17) = 5.0/256.0;
+      prolongation[4](8,24) = 45.0/256.0;
+      prolongation[4](8,25) = 45.0/256.0;
+      prolongation[4](8,26) = 9.0/256.0;
+      prolongation[4](8,27) = 9.0/256.0;
+      prolongation[4](8,40) = 135.0/256.0;
+      prolongation[4](8,41) = -45.0/256.0;
+      prolongation[4](8,42) = 135.0/256.0;
+      prolongation[4](8,43) = -45.0/256.0;
+      prolongation[4](9,8) = -1.0/16.0;
+      prolongation[4](9,16) = -1.0/16.0;
+      prolongation[4](9,40) = 9.0/16.0;
+      prolongation[4](9,42) = 9.0/16.0;
+      prolongation[4](10,0) = 5.0/4096.0;
+      prolongation[4](10,1) = 5.0/4096.0;
+      prolongation[4](10,2) = 1.0/4096.0;
+      prolongation[4](10,3) = 1.0/4096.0;
+      prolongation[4](10,4) = 5.0/4096.0;
+      prolongation[4](10,5) = 5.0/4096.0;
+      prolongation[4](10,6) = 1.0/4096.0;
+      prolongation[4](10,7) = 1.0/4096.0;
+      prolongation[4](10,8) = -45.0/4096.0;
+      prolongation[4](10,9) = -45.0/4096.0;
+      prolongation[4](10,10) = 15.0/4096.0;
+      prolongation[4](10,11) = -5.0/4096.0;
+      prolongation[4](10,12) = -9.0/4096.0;
+      prolongation[4](10,13) = -9.0/4096.0;
+      prolongation[4](10,14) = 15.0/4096.0;
+      prolongation[4](10,15) = -5.0/4096.0;
+      prolongation[4](10,16) = -45.0/4096.0;
+      prolongation[4](10,17) = -45.0/4096.0;
+      prolongation[4](10,18) = 15.0/4096.0;
+      prolongation[4](10,19) = -5.0/4096.0;
+      prolongation[4](10,20) = -9.0/4096.0;
+      prolongation[4](10,21) = -9.0/4096.0;
+      prolongation[4](10,22) = 15.0/4096.0;
+      prolongation[4](10,23) = -5.0/4096.0;
+      prolongation[4](10,24) = -45.0/4096.0;
+      prolongation[4](10,25) = -45.0/4096.0;
+      prolongation[4](10,26) = -45.0/4096.0;
+      prolongation[4](10,27) = -45.0/4096.0;
+      prolongation[4](10,28) = -9.0/4096.0;
+      prolongation[4](10,29) = -9.0/4096.0;
+      prolongation[4](10,30) = -9.0/4096.0;
+      prolongation[4](10,31) = -9.0/4096.0;
+      prolongation[4](10,32) = -135.0/4096.0;
+      prolongation[4](10,33) = -135.0/4096.0;
+      prolongation[4](10,34) = 45.0/4096.0;
+      prolongation[4](10,35) = 45.0/4096.0;
+      prolongation[4](10,36) = -135.0/4096.0;
+      prolongation[4](10,37) = -135.0/4096.0;
+      prolongation[4](10,38) = 45.0/4096.0;
+      prolongation[4](10,39) = 45.0/4096.0;
+      prolongation[4](10,40) = 405.0/4096.0;
+      prolongation[4](10,41) = 405.0/4096.0;
+      prolongation[4](10,42) = 405.0/4096.0;
+      prolongation[4](10,43) = 405.0/4096.0;
+      prolongation[4](10,44) = -135.0/4096.0;
+      prolongation[4](10,45) = -135.0/4096.0;
+      prolongation[4](10,46) = 45.0/4096.0;
+      prolongation[4](10,47) = 45.0/4096.0;
+      prolongation[4](10,48) = 81.0/4096.0;
+      prolongation[4](10,49) = 81.0/4096.0;
+      prolongation[4](10,50) = 81.0/4096.0;
+      prolongation[4](10,51) = 81.0/4096.0;
+      prolongation[4](10,52) = -135.0/4096.0;
+      prolongation[4](10,53) = -135.0/4096.0;
+      prolongation[4](10,54) = 45.0/4096.0;
+      prolongation[4](10,55) = 45.0/4096.0;
+      prolongation[4](10,56) = 1215.0/4096.0;
+      prolongation[4](10,57) = 1215.0/4096.0;
+      prolongation[4](10,58) = 1215.0/4096.0;
+      prolongation[4](10,59) = 1215.0/4096.0;
+      prolongation[4](10,60) = -405.0/4096.0;
+      prolongation[4](10,61) = -405.0/4096.0;
+      prolongation[4](10,62) = -405.0/4096.0;
+      prolongation[4](10,63) = -405.0/4096.0;
+      prolongation[4](11,10) = 1.0/256.0;
+      prolongation[4](11,14) = 1.0/256.0;
+      prolongation[4](11,18) = 1.0/256.0;
+      prolongation[4](11,22) = 1.0/256.0;
+      prolongation[4](11,32) = -9.0/256.0;
+      prolongation[4](11,33) = -9.0/256.0;
+      prolongation[4](11,36) = -9.0/256.0;
+      prolongation[4](11,37) = -9.0/256.0;
+      prolongation[4](11,44) = -9.0/256.0;
+      prolongation[4](11,45) = -9.0/256.0;
+      prolongation[4](11,52) = -9.0/256.0;
+      prolongation[4](11,53) = -9.0/256.0;
+      prolongation[4](11,56) = 81.0/256.0;
+      prolongation[4](11,57) = 81.0/256.0;
+      prolongation[4](11,58) = 81.0/256.0;
+      prolongation[4](11,59) = 81.0/256.0;
+      prolongation[4](12,0) = 5.0/4096.0;
+      prolongation[4](12,1) = 1.0/4096.0;
+      prolongation[4](12,2) = 1.0/4096.0;
+      prolongation[4](12,3) = 5.0/4096.0;
+      prolongation[4](12,4) = 5.0/4096.0;
+      prolongation[4](12,5) = 1.0/4096.0;
+      prolongation[4](12,6) = 1.0/4096.0;
+      prolongation[4](12,7) = 5.0/4096.0;
+      prolongation[4](12,8) = 15.0/4096.0;
+      prolongation[4](12,9) = -5.0/4096.0;
+      prolongation[4](12,10) = -9.0/4096.0;
+      prolongation[4](12,11) = -9.0/4096.0;
+      prolongation[4](12,12) = 15.0/4096.0;
+      prolongation[4](12,13) = -5.0/4096.0;
+      prolongation[4](12,14) = -45.0/4096.0;
+      prolongation[4](12,15) = -45.0/4096.0;
+      prolongation[4](12,16) = 15.0/4096.0;
+      prolongation[4](12,17) = -5.0/4096.0;
+      prolongation[4](12,18) = -9.0/4096.0;
+      prolongation[4](12,19) = -9.0/4096.0;
+      prolongation[4](12,20) = 15.0/4096.0;
+      prolongation[4](12,21) = -5.0/4096.0;
+      prolongation[4](12,22) = -45.0/4096.0;
+      prolongation[4](12,23) = -45.0/4096.0;
+      prolongation[4](12,24) = -45.0/4096.0;
+      prolongation[4](12,25) = -45.0/4096.0;
+      prolongation[4](12,26) = -9.0/4096.0;
+      prolongation[4](12,27) = -9.0/4096.0;
+      prolongation[4](12,28) = -9.0/4096.0;
+      prolongation[4](12,29) = -9.0/4096.0;
+      prolongation[4](12,30) = -45.0/4096.0;
+      prolongation[4](12,31) = -45.0/4096.0;
+      prolongation[4](12,32) = -135.0/4096.0;
+      prolongation[4](12,33) = 45.0/4096.0;
+      prolongation[4](12,34) = -135.0/4096.0;
+      prolongation[4](12,35) = 45.0/4096.0;
+      prolongation[4](12,36) = -135.0/4096.0;
+      prolongation[4](12,37) = 45.0/4096.0;
+      prolongation[4](12,38) = -135.0/4096.0;
+      prolongation[4](12,39) = 45.0/4096.0;
+      prolongation[4](12,40) = -135.0/4096.0;
+      prolongation[4](12,41) = 45.0/4096.0;
+      prolongation[4](12,42) = -135.0/4096.0;
+      prolongation[4](12,43) = 45.0/4096.0;
+      prolongation[4](12,44) = 81.0/4096.0;
+      prolongation[4](12,45) = 81.0/4096.0;
+      prolongation[4](12,46) = 81.0/4096.0;
+      prolongation[4](12,47) = 81.0/4096.0;
+      prolongation[4](12,48) = -135.0/4096.0;
+      prolongation[4](12,49) = 45.0/4096.0;
+      prolongation[4](12,50) = -135.0/4096.0;
+      prolongation[4](12,51) = 45.0/4096.0;
+      prolongation[4](12,52) = 405.0/4096.0;
+      prolongation[4](12,53) = 405.0/4096.0;
+      prolongation[4](12,54) = 405.0/4096.0;
+      prolongation[4](12,55) = 405.0/4096.0;
+      prolongation[4](12,56) = 1215.0/4096.0;
+      prolongation[4](12,57) = -405.0/4096.0;
+      prolongation[4](12,58) = 1215.0/4096.0;
+      prolongation[4](12,59) = -405.0/4096.0;
+      prolongation[4](12,60) = 1215.0/4096.0;
+      prolongation[4](12,61) = -405.0/4096.0;
+      prolongation[4](12,62) = 1215.0/4096.0;
+      prolongation[4](12,63) = -405.0/4096.0;
+      prolongation[4](13,8) = 1.0/256.0;
+      prolongation[4](13,12) = 1.0/256.0;
+      prolongation[4](13,16) = 1.0/256.0;
+      prolongation[4](13,20) = 1.0/256.0;
+      prolongation[4](13,32) = -9.0/256.0;
+      prolongation[4](13,34) = -9.0/256.0;
+      prolongation[4](13,36) = -9.0/256.0;
+      prolongation[4](13,38) = -9.0/256.0;
+      prolongation[4](13,40) = -9.0/256.0;
+      prolongation[4](13,42) = -9.0/256.0;
+      prolongation[4](13,48) = -9.0/256.0;
+      prolongation[4](13,50) = -9.0/256.0;
+      prolongation[4](13,56) = 81.0/256.0;
+      prolongation[4](13,58) = 81.0/256.0;
+      prolongation[4](13,60) = 81.0/256.0;
+      prolongation[4](13,62) = 81.0/256.0;
+      prolongation[4](14,0) = -5.0/256.0;
+      prolongation[4](14,3) = -1.0/256.0;
+      prolongation[4](14,4) = -5.0/256.0;
+      prolongation[4](14,7) = -1.0/256.0;
+      prolongation[4](14,14) = -15.0/256.0;
+      prolongation[4](14,15) = 5.0/256.0;
+      prolongation[4](14,22) = -15.0/256.0;
+      prolongation[4](14,23) = 5.0/256.0;
+      prolongation[4](14,24) = 45.0/256.0;
+      prolongation[4](14,25) = 45.0/256.0;
+      prolongation[4](14,30) = 9.0/256.0;
+      prolongation[4](14,31) = 9.0/256.0;
+      prolongation[4](14,52) = 135.0/256.0;
+      prolongation[4](14,53) = 135.0/256.0;
+      prolongation[4](14,54) = -45.0/256.0;
+      prolongation[4](14,55) = -45.0/256.0;
+      prolongation[4](15,14) = -1.0/16.0;
+      prolongation[4](15,22) = -1.0/16.0;
+      prolongation[4](15,52) = 9.0/16.0;
+      prolongation[4](15,53) = 9.0/16.0;
+      prolongation[4](16,4) = 5.0/16.0;
+      prolongation[4](16,5) = 1.0/16.0;
+      prolongation[4](16,16) = 15.0/16.0;
+      prolongation[4](16,17) = -5.0/16.0;
+      prolongation[4](17,16) = 1.0;
+      prolongation[4](18,4) = -5.0/256.0;
+      prolongation[4](18,5) = -5.0/256.0;
+      prolongation[4](18,6) = -1.0/256.0;
+      prolongation[4](18,7) = -1.0/256.0;
+      prolongation[4](18,16) = 45.0/256.0;
+      prolongation[4](18,17) = 45.0/256.0;
+      prolongation[4](18,18) = -15.0/256.0;
+      prolongation[4](18,19) = 5.0/256.0;
+      prolongation[4](18,20) = 9.0/256.0;
+      prolongation[4](18,21) = 9.0/256.0;
+      prolongation[4](18,22) = -15.0/256.0;
+      prolongation[4](18,23) = 5.0/256.0;
+      prolongation[4](18,36) = 135.0/256.0;
+      prolongation[4](18,37) = 135.0/256.0;
+      prolongation[4](18,38) = -45.0/256.0;
+      prolongation[4](18,39) = -45.0/256.0;
+      prolongation[4](19,18) = -1.0/16.0;
+      prolongation[4](19,22) = -1.0/16.0;
+      prolongation[4](19,36) = 9.0/16.0;
+      prolongation[4](19,37) = 9.0/16.0;
+      prolongation[4](20,4) = -5.0/256.0;
+      prolongation[4](20,5) = -1.0/256.0;
+      prolongation[4](20,6) = -1.0/256.0;
+      prolongation[4](20,7) = -5.0/256.0;
+      prolongation[4](20,16) = -15.0/256.0;
+      prolongation[4](20,17) = 5.0/256.0;
+      prolongation[4](20,18) = 9.0/256.0;
+      prolongation[4](20,19) = 9.0/256.0;
+      prolongation[4](20,20) = -15.0/256.0;
+      prolongation[4](20,21) = 5.0/256.0;
+      prolongation[4](20,22) = 45.0/256.0;
+      prolongation[4](20,23) = 45.0/256.0;
+      prolongation[4](20,36) = 135.0/256.0;
+      prolongation[4](20,37) = -45.0/256.0;
+      prolongation[4](20,38) = 135.0/256.0;
+      prolongation[4](20,39) = -45.0/256.0;
+      prolongation[4](21,16) = -1.0/16.0;
+      prolongation[4](21,20) = -1.0/16.0;
+      prolongation[4](21,36) = 9.0/16.0;
+      prolongation[4](21,38) = 9.0/16.0;
+      prolongation[4](22,4) = 5.0/16.0;
+      prolongation[4](22,7) = 1.0/16.0;
+      prolongation[4](22,22) = 15.0/16.0;
+      prolongation[4](22,23) = -5.0/16.0;
+      prolongation[4](23,22) = 1.0;
+      prolongation[4](24,25) = 1.0;
+      prolongation[4](25,0) = 1.0/16.0;
+      prolongation[4](25,4) = 5.0/16.0;
+      prolongation[4](25,24) = -5.0/16.0;
+      prolongation[4](25,25) = 15.0/16.0;
+      prolongation[4](26,25) = -1.0/16.0;
+      prolongation[4](26,27) = -1.0/16.0;
+      prolongation[4](26,42) = 9.0/16.0;
+      prolongation[4](26,43) = 9.0/16.0;
+      prolongation[4](27,0) = -1.0/256.0;
+      prolongation[4](27,1) = -1.0/256.0;
+      prolongation[4](27,4) = -5.0/256.0;
+      prolongation[4](27,5) = -5.0/256.0;
+      prolongation[4](27,8) = 9.0/256.0;
+      prolongation[4](27,9) = 9.0/256.0;
+      prolongation[4](27,16) = 45.0/256.0;
+      prolongation[4](27,17) = 45.0/256.0;
+      prolongation[4](27,24) = 5.0/256.0;
+      prolongation[4](27,25) = -15.0/256.0;
+      prolongation[4](27,26) = 5.0/256.0;
+      prolongation[4](27,27) = -15.0/256.0;
+      prolongation[4](27,40) = -45.0/256.0;
+      prolongation[4](27,41) = -45.0/256.0;
+      prolongation[4](27,42) = 135.0/256.0;
+      prolongation[4](27,43) = 135.0/256.0;
+      prolongation[4](28,25) = 1.0/256.0;
+      prolongation[4](28,27) = 1.0/256.0;
+      prolongation[4](28,29) = 1.0/256.0;
+      prolongation[4](28,31) = 1.0/256.0;
+      prolongation[4](28,42) = -9.0/256.0;
+      prolongation[4](28,43) = -9.0/256.0;
+      prolongation[4](28,45) = -9.0/256.0;
+      prolongation[4](28,47) = -9.0/256.0;
+      prolongation[4](28,50) = -9.0/256.0;
+      prolongation[4](28,51) = -9.0/256.0;
+      prolongation[4](28,53) = -9.0/256.0;
+      prolongation[4](28,55) = -9.0/256.0;
+      prolongation[4](28,58) = 81.0/256.0;
+      prolongation[4](28,59) = 81.0/256.0;
+      prolongation[4](28,62) = 81.0/256.0;
+      prolongation[4](28,63) = 81.0/256.0;
+      prolongation[4](29,0) = 1.0/4096.0;
+      prolongation[4](29,1) = 1.0/4096.0;
+      prolongation[4](29,2) = 1.0/4096.0;
+      prolongation[4](29,3) = 1.0/4096.0;
+      prolongation[4](29,4) = 5.0/4096.0;
+      prolongation[4](29,5) = 5.0/4096.0;
+      prolongation[4](29,6) = 5.0/4096.0;
+      prolongation[4](29,7) = 5.0/4096.0;
+      prolongation[4](29,8) = -9.0/4096.0;
+      prolongation[4](29,9) = -9.0/4096.0;
+      prolongation[4](29,10) = -9.0/4096.0;
+      prolongation[4](29,11) = -9.0/4096.0;
+      prolongation[4](29,12) = -9.0/4096.0;
+      prolongation[4](29,13) = -9.0/4096.0;
+      prolongation[4](29,14) = -9.0/4096.0;
+      prolongation[4](29,15) = -9.0/4096.0;
+      prolongation[4](29,16) = -45.0/4096.0;
+      prolongation[4](29,17) = -45.0/4096.0;
+      prolongation[4](29,18) = -45.0/4096.0;
+      prolongation[4](29,19) = -45.0/4096.0;
+      prolongation[4](29,20) = -45.0/4096.0;
+      prolongation[4](29,21) = -45.0/4096.0;
+      prolongation[4](29,22) = -45.0/4096.0;
+      prolongation[4](29,23) = -45.0/4096.0;
+      prolongation[4](29,24) = -5.0/4096.0;
+      prolongation[4](29,25) = 15.0/4096.0;
+      prolongation[4](29,26) = -5.0/4096.0;
+      prolongation[4](29,27) = 15.0/4096.0;
+      prolongation[4](29,28) = -5.0/4096.0;
+      prolongation[4](29,29) = 15.0/4096.0;
+      prolongation[4](29,30) = -5.0/4096.0;
+      prolongation[4](29,31) = 15.0/4096.0;
+      prolongation[4](29,32) = 81.0/4096.0;
+      prolongation[4](29,33) = 81.0/4096.0;
+      prolongation[4](29,34) = 81.0/4096.0;
+      prolongation[4](29,35) = 81.0/4096.0;
+      prolongation[4](29,36) = 405.0/4096.0;
+      prolongation[4](29,37) = 405.0/4096.0;
+      prolongation[4](29,38) = 405.0/4096.0;
+      prolongation[4](29,39) = 405.0/4096.0;
+      prolongation[4](29,40) = 45.0/4096.0;
+      prolongation[4](29,41) = 45.0/4096.0;
+      prolongation[4](29,42) = -135.0/4096.0;
+      prolongation[4](29,43) = -135.0/4096.0;
+      prolongation[4](29,44) = 45.0/4096.0;
+      prolongation[4](29,45) = -135.0/4096.0;
+      prolongation[4](29,46) = 45.0/4096.0;
+      prolongation[4](29,47) = -135.0/4096.0;
+      prolongation[4](29,48) = 45.0/4096.0;
+      prolongation[4](29,49) = 45.0/4096.0;
+      prolongation[4](29,50) = -135.0/4096.0;
+      prolongation[4](29,51) = -135.0/4096.0;
+      prolongation[4](29,52) = 45.0/4096.0;
+      prolongation[4](29,53) = -135.0/4096.0;
+      prolongation[4](29,54) = 45.0/4096.0;
+      prolongation[4](29,55) = -135.0/4096.0;
+      prolongation[4](29,56) = -405.0/4096.0;
+      prolongation[4](29,57) = -405.0/4096.0;
+      prolongation[4](29,58) = 1215.0/4096.0;
+      prolongation[4](29,59) = 1215.0/4096.0;
+      prolongation[4](29,60) = -405.0/4096.0;
+      prolongation[4](29,61) = -405.0/4096.0;
+      prolongation[4](29,62) = 1215.0/4096.0;
+      prolongation[4](29,63) = 1215.0/4096.0;
+      prolongation[4](30,25) = -1.0/16.0;
+      prolongation[4](30,31) = -1.0/16.0;
+      prolongation[4](30,53) = 9.0/16.0;
+      prolongation[4](30,55) = 9.0/16.0;
+      prolongation[4](31,0) = -1.0/256.0;
+      prolongation[4](31,3) = -1.0/256.0;
+      prolongation[4](31,4) = -5.0/256.0;
+      prolongation[4](31,7) = -5.0/256.0;
+      prolongation[4](31,14) = 9.0/256.0;
+      prolongation[4](31,15) = 9.0/256.0;
+      prolongation[4](31,22) = 45.0/256.0;
+      prolongation[4](31,23) = 45.0/256.0;
+      prolongation[4](31,24) = 5.0/256.0;
+      prolongation[4](31,25) = -15.0/256.0;
+      prolongation[4](31,30) = 5.0/256.0;
+      prolongation[4](31,31) = -15.0/256.0;
+      prolongation[4](31,52) = -45.0/256.0;
+      prolongation[4](31,53) = 135.0/256.0;
+      prolongation[4](31,54) = -45.0/256.0;
+      prolongation[4](31,55) = 135.0/256.0;
+      prolongation[4](32,0) = -25.0/4096.0;
+      prolongation[4](32,1) = -5.0/4096.0;
+      prolongation[4](32,2) = -1.0/4096.0;
+      prolongation[4](32,3) = -5.0/4096.0;
+      prolongation[4](32,4) = -25.0/4096.0;
+      prolongation[4](32,5) = -5.0/4096.0;
+      prolongation[4](32,6) = -1.0/4096.0;
+      prolongation[4](32,7) = -5.0/4096.0;
+      prolongation[4](32,8) = -75.0/4096.0;
+      prolongation[4](32,9) = 25.0/4096.0;
+      prolongation[4](32,10) = -15.0/4096.0;
+      prolongation[4](32,11) = 5.0/4096.0;
+      prolongation[4](32,12) = -15.0/4096.0;
+      prolongation[4](32,13) = 5.0/4096.0;
+      prolongation[4](32,14) = -75.0/4096.0;
+      prolongation[4](32,15) = 25.0/4096.0;
+      prolongation[4](32,16) = -75.0/4096.0;
+      prolongation[4](32,17) = 25.0/4096.0;
+      prolongation[4](32,18) = -15.0/4096.0;
+      prolongation[4](32,19) = 5.0/4096.0;
+      prolongation[4](32,20) = -15.0/4096.0;
+      prolongation[4](32,21) = 5.0/4096.0;
+      prolongation[4](32,22) = -75.0/4096.0;
+      prolongation[4](32,23) = 25.0/4096.0;
+      prolongation[4](32,24) = 225.0/4096.0;
+      prolongation[4](32,25) = 225.0/4096.0;
+      prolongation[4](32,26) = 45.0/4096.0;
+      prolongation[4](32,27) = 45.0/4096.0;
+      prolongation[4](32,28) = 9.0/4096.0;
+      prolongation[4](32,29) = 9.0/4096.0;
+      prolongation[4](32,30) = 45.0/4096.0;
+      prolongation[4](32,31) = 45.0/4096.0;
+      prolongation[4](32,32) = -225.0/4096.0;
+      prolongation[4](32,33) = 75.0/4096.0;
+      prolongation[4](32,34) = 75.0/4096.0;
+      prolongation[4](32,35) = -25.0/4096.0;
+      prolongation[4](32,36) = -225.0/4096.0;
+      prolongation[4](32,37) = 75.0/4096.0;
+      prolongation[4](32,38) = 75.0/4096.0;
+      prolongation[4](32,39) = -25.0/4096.0;
+      prolongation[4](32,40) = 675.0/4096.0;
+      prolongation[4](32,41) = -225.0/4096.0;
+      prolongation[4](32,42) = 675.0/4096.0;
+      prolongation[4](32,43) = -225.0/4096.0;
+      prolongation[4](32,44) = 135.0/4096.0;
+      prolongation[4](32,45) = 135.0/4096.0;
+      prolongation[4](32,46) = -45.0/4096.0;
+      prolongation[4](32,47) = -45.0/4096.0;
+      prolongation[4](32,48) = 135.0/4096.0;
+      prolongation[4](32,49) = -45.0/4096.0;
+      prolongation[4](32,50) = 135.0/4096.0;
+      prolongation[4](32,51) = -45.0/4096.0;
+      prolongation[4](32,52) = 675.0/4096.0;
+      prolongation[4](32,53) = 675.0/4096.0;
+      prolongation[4](32,54) = -225.0/4096.0;
+      prolongation[4](32,55) = -225.0/4096.0;
+      prolongation[4](32,56) = 2025.0/4096.0;
+      prolongation[4](32,57) = -675.0/4096.0;
+      prolongation[4](32,58) = 2025.0/4096.0;
+      prolongation[4](32,59) = -675.0/4096.0;
+      prolongation[4](32,60) = -675.0/4096.0;
+      prolongation[4](32,61) = 225.0/4096.0;
+      prolongation[4](32,62) = -675.0/4096.0;
+      prolongation[4](32,63) = 225.0/4096.0;
+      prolongation[4](33,8) = -5.0/256.0;
+      prolongation[4](33,12) = -1.0/256.0;
+      prolongation[4](33,16) = -5.0/256.0;
+      prolongation[4](33,20) = -1.0/256.0;
+      prolongation[4](33,32) = -15.0/256.0;
+      prolongation[4](33,34) = 5.0/256.0;
+      prolongation[4](33,36) = -15.0/256.0;
+      prolongation[4](33,38) = 5.0/256.0;
+      prolongation[4](33,40) = 45.0/256.0;
+      prolongation[4](33,42) = 45.0/256.0;
+      prolongation[4](33,48) = 9.0/256.0;
+      prolongation[4](33,50) = 9.0/256.0;
+      prolongation[4](33,56) = 135.0/256.0;
+      prolongation[4](33,58) = 135.0/256.0;
+      prolongation[4](33,60) = -45.0/256.0;
+      prolongation[4](33,62) = -45.0/256.0;
+      prolongation[4](34,10) = -1.0/256.0;
+      prolongation[4](34,14) = -5.0/256.0;
+      prolongation[4](34,18) = -1.0/256.0;
+      prolongation[4](34,22) = -5.0/256.0;
+      prolongation[4](34,32) = -15.0/256.0;
+      prolongation[4](34,33) = 5.0/256.0;
+      prolongation[4](34,36) = -15.0/256.0;
+      prolongation[4](34,37) = 5.0/256.0;
+      prolongation[4](34,44) = 9.0/256.0;
+      prolongation[4](34,45) = 9.0/256.0;
+      prolongation[4](34,52) = 45.0/256.0;
+      prolongation[4](34,53) = 45.0/256.0;
+      prolongation[4](34,56) = 135.0/256.0;
+      prolongation[4](34,57) = -45.0/256.0;
+      prolongation[4](34,58) = 135.0/256.0;
+      prolongation[4](34,59) = -45.0/256.0;
+      prolongation[4](35,32) = -1.0/16.0;
+      prolongation[4](35,36) = -1.0/16.0;
+      prolongation[4](35,56) = 9.0/16.0;
+      prolongation[4](35,58) = 9.0/16.0;
+      prolongation[4](36,4) = 25.0/256.0;
+      prolongation[4](36,5) = 5.0/256.0;
+      prolongation[4](36,6) = 1.0/256.0;
+      prolongation[4](36,7) = 5.0/256.0;
+      prolongation[4](36,16) = 75.0/256.0;
+      prolongation[4](36,17) = -25.0/256.0;
+      prolongation[4](36,18) = 15.0/256.0;
+      prolongation[4](36,19) = -5.0/256.0;
+      prolongation[4](36,20) = 15.0/256.0;
+      prolongation[4](36,21) = -5.0/256.0;
+      prolongation[4](36,22) = 75.0/256.0;
+      prolongation[4](36,23) = -25.0/256.0;
+      prolongation[4](36,36) = 225.0/256.0;
+      prolongation[4](36,37) = -75.0/256.0;
+      prolongation[4](36,38) = -75.0/256.0;
+      prolongation[4](36,39) = 25.0/256.0;
+      prolongation[4](37,16) = 5.0/16.0;
+      prolongation[4](37,20) = 1.0/16.0;
+      prolongation[4](37,36) = 15.0/16.0;
+      prolongation[4](37,38) = -5.0/16.0;
+      prolongation[4](38,18) = 1.0/16.0;
+      prolongation[4](38,22) = 5.0/16.0;
+      prolongation[4](38,36) = 15.0/16.0;
+      prolongation[4](38,37) = -5.0/16.0;
+      prolongation[4](39,36) = 1.0;
+      prolongation[4](40,25) = 5.0/16.0;
+      prolongation[4](40,27) = 1.0/16.0;
+      prolongation[4](40,42) = 15.0/16.0;
+      prolongation[4](40,43) = -5.0/16.0;
+      prolongation[4](41,42) = 1.0;
+      prolongation[4](42,0) = 5.0/256.0;
+      prolongation[4](42,1) = 1.0/256.0;
+      prolongation[4](42,4) = 25.0/256.0;
+      prolongation[4](42,5) = 5.0/256.0;
+      prolongation[4](42,8) = 15.0/256.0;
+      prolongation[4](42,9) = -5.0/256.0;
+      prolongation[4](42,16) = 75.0/256.0;
+      prolongation[4](42,17) = -25.0/256.0;
+      prolongation[4](42,24) = -25.0/256.0;
+      prolongation[4](42,25) = 75.0/256.0;
+      prolongation[4](42,26) = -5.0/256.0;
+      prolongation[4](42,27) = 15.0/256.0;
+      prolongation[4](42,40) = -75.0/256.0;
+      prolongation[4](42,41) = 25.0/256.0;
+      prolongation[4](42,42) = 225.0/256.0;
+      prolongation[4](42,43) = -75.0/256.0;
+      prolongation[4](43,8) = 1.0/16.0;
+      prolongation[4](43,16) = 5.0/16.0;
+      prolongation[4](43,40) = -5.0/16.0;
+      prolongation[4](43,42) = 15.0/16.0;
+      prolongation[4](44,25) = -5.0/256.0;
+      prolongation[4](44,27) = -5.0/256.0;
+      prolongation[4](44,29) = -1.0/256.0;
+      prolongation[4](44,31) = -1.0/256.0;
+      prolongation[4](44,42) = 45.0/256.0;
+      prolongation[4](44,43) = 45.0/256.0;
+      prolongation[4](44,45) = -15.0/256.0;
+      prolongation[4](44,47) = 5.0/256.0;
+      prolongation[4](44,50) = 9.0/256.0;
+      prolongation[4](44,51) = 9.0/256.0;
+      prolongation[4](44,53) = -15.0/256.0;
+      prolongation[4](44,55) = 5.0/256.0;
+      prolongation[4](44,58) = 135.0/256.0;
+      prolongation[4](44,59) = 135.0/256.0;
+      prolongation[4](44,62) = -45.0/256.0;
+      prolongation[4](44,63) = -45.0/256.0;
+      prolongation[4](45,0) = -5.0/4096.0;
+      prolongation[4](45,1) = -5.0/4096.0;
+      prolongation[4](45,2) = -1.0/4096.0;
+      prolongation[4](45,3) = -1.0/4096.0;
+      prolongation[4](45,4) = -25.0/4096.0;
+      prolongation[4](45,5) = -25.0/4096.0;
+      prolongation[4](45,6) = -5.0/4096.0;
+      prolongation[4](45,7) = -5.0/4096.0;
+      prolongation[4](45,8) = 45.0/4096.0;
+      prolongation[4](45,9) = 45.0/4096.0;
+      prolongation[4](45,10) = -15.0/4096.0;
+      prolongation[4](45,11) = 5.0/4096.0;
+      prolongation[4](45,12) = 9.0/4096.0;
+      prolongation[4](45,13) = 9.0/4096.0;
+      prolongation[4](45,14) = -15.0/4096.0;
+      prolongation[4](45,15) = 5.0/4096.0;
+      prolongation[4](45,16) = 225.0/4096.0;
+      prolongation[4](45,17) = 225.0/4096.0;
+      prolongation[4](45,18) = -75.0/4096.0;
+      prolongation[4](45,19) = 25.0/4096.0;
+      prolongation[4](45,20) = 45.0/4096.0;
+      prolongation[4](45,21) = 45.0/4096.0;
+      prolongation[4](45,22) = -75.0/4096.0;
+      prolongation[4](45,23) = 25.0/4096.0;
+      prolongation[4](45,24) = 25.0/4096.0;
+      prolongation[4](45,25) = -75.0/4096.0;
+      prolongation[4](45,26) = 25.0/4096.0;
+      prolongation[4](45,27) = -75.0/4096.0;
+      prolongation[4](45,28) = 5.0/4096.0;
+      prolongation[4](45,29) = -15.0/4096.0;
+      prolongation[4](45,30) = 5.0/4096.0;
+      prolongation[4](45,31) = -15.0/4096.0;
+      prolongation[4](45,32) = 135.0/4096.0;
+      prolongation[4](45,33) = 135.0/4096.0;
+      prolongation[4](45,34) = -45.0/4096.0;
+      prolongation[4](45,35) = -45.0/4096.0;
+      prolongation[4](45,36) = 675.0/4096.0;
+      prolongation[4](45,37) = 675.0/4096.0;
+      prolongation[4](45,38) = -225.0/4096.0;
+      prolongation[4](45,39) = -225.0/4096.0;
+      prolongation[4](45,40) = -225.0/4096.0;
+      prolongation[4](45,41) = -225.0/4096.0;
+      prolongation[4](45,42) = 675.0/4096.0;
+      prolongation[4](45,43) = 675.0/4096.0;
+      prolongation[4](45,44) = 75.0/4096.0;
+      prolongation[4](45,45) = -225.0/4096.0;
+      prolongation[4](45,46) = -25.0/4096.0;
+      prolongation[4](45,47) = 75.0/4096.0;
+      prolongation[4](45,48) = -45.0/4096.0;
+      prolongation[4](45,49) = -45.0/4096.0;
+      prolongation[4](45,50) = 135.0/4096.0;
+      prolongation[4](45,51) = 135.0/4096.0;
+      prolongation[4](45,52) = 75.0/4096.0;
+      prolongation[4](45,53) = -225.0/4096.0;
+      prolongation[4](45,54) = -25.0/4096.0;
+      prolongation[4](45,55) = 75.0/4096.0;
+      prolongation[4](45,56) = -675.0/4096.0;
+      prolongation[4](45,57) = -675.0/4096.0;
+      prolongation[4](45,58) = 2025.0/4096.0;
+      prolongation[4](45,59) = 2025.0/4096.0;
+      prolongation[4](45,60) = 225.0/4096.0;
+      prolongation[4](45,61) = 225.0/4096.0;
+      prolongation[4](45,62) = -675.0/4096.0;
+      prolongation[4](45,63) = -675.0/4096.0;
+      prolongation[4](46,45) = -1.0/16.0;
+      prolongation[4](46,53) = -1.0/16.0;
+      prolongation[4](46,58) = 9.0/16.0;
+      prolongation[4](46,59) = 9.0/16.0;
+      prolongation[4](47,10) = -1.0/256.0;
+      prolongation[4](47,14) = -1.0/256.0;
+      prolongation[4](47,18) = -5.0/256.0;
+      prolongation[4](47,22) = -5.0/256.0;
+      prolongation[4](47,32) = 9.0/256.0;
+      prolongation[4](47,33) = 9.0/256.0;
+      prolongation[4](47,36) = 45.0/256.0;
+      prolongation[4](47,37) = 45.0/256.0;
+      prolongation[4](47,44) = 5.0/256.0;
+      prolongation[4](47,45) = -15.0/256.0;
+      prolongation[4](47,52) = 5.0/256.0;
+      prolongation[4](47,53) = -15.0/256.0;
+      prolongation[4](47,56) = -45.0/256.0;
+      prolongation[4](47,57) = -45.0/256.0;
+      prolongation[4](47,58) = 135.0/256.0;
+      prolongation[4](47,59) = 135.0/256.0;
+      prolongation[4](48,25) = -5.0/256.0;
+      prolongation[4](48,27) = -1.0/256.0;
+      prolongation[4](48,29) = -1.0/256.0;
+      prolongation[4](48,31) = -5.0/256.0;
+      prolongation[4](48,42) = -15.0/256.0;
+      prolongation[4](48,43) = 5.0/256.0;
+      prolongation[4](48,45) = 9.0/256.0;
+      prolongation[4](48,47) = 9.0/256.0;
+      prolongation[4](48,50) = -15.0/256.0;
+      prolongation[4](48,51) = 5.0/256.0;
+      prolongation[4](48,53) = 45.0/256.0;
+      prolongation[4](48,55) = 45.0/256.0;
+      prolongation[4](48,58) = 135.0/256.0;
+      prolongation[4](48,59) = -45.0/256.0;
+      prolongation[4](48,62) = 135.0/256.0;
+      prolongation[4](48,63) = -45.0/256.0;
+      prolongation[4](49,42) = -1.0/16.0;
+      prolongation[4](49,50) = -1.0/16.0;
+      prolongation[4](49,58) = 9.0/16.0;
+      prolongation[4](49,62) = 9.0/16.0;
+      prolongation[4](50,0) = -5.0/4096.0;
+      prolongation[4](50,1) = -1.0/4096.0;
+      prolongation[4](50,2) = -1.0/4096.0;
+      prolongation[4](50,3) = -5.0/4096.0;
+      prolongation[4](50,4) = -25.0/4096.0;
+      prolongation[4](50,5) = -5.0/4096.0;
+      prolongation[4](50,6) = -5.0/4096.0;
+      prolongation[4](50,7) = -25.0/4096.0;
+      prolongation[4](50,8) = -15.0/4096.0;
+      prolongation[4](50,9) = 5.0/4096.0;
+      prolongation[4](50,10) = 9.0/4096.0;
+      prolongation[4](50,11) = 9.0/4096.0;
+      prolongation[4](50,12) = -15.0/4096.0;
+      prolongation[4](50,13) = 5.0/4096.0;
+      prolongation[4](50,14) = 45.0/4096.0;
+      prolongation[4](50,15) = 45.0/4096.0;
+      prolongation[4](50,16) = -75.0/4096.0;
+      prolongation[4](50,17) = 25.0/4096.0;
+      prolongation[4](50,18) = 45.0/4096.0;
+      prolongation[4](50,19) = 45.0/4096.0;
+      prolongation[4](50,20) = -75.0/4096.0;
+      prolongation[4](50,21) = 25.0/4096.0;
+      prolongation[4](50,22) = 225.0/4096.0;
+      prolongation[4](50,23) = 225.0/4096.0;
+      prolongation[4](50,24) = 25.0/4096.0;
+      prolongation[4](50,25) = -75.0/4096.0;
+      prolongation[4](50,26) = 5.0/4096.0;
+      prolongation[4](50,27) = -15.0/4096.0;
+      prolongation[4](50,28) = 5.0/4096.0;
+      prolongation[4](50,29) = -15.0/4096.0;
+      prolongation[4](50,30) = 25.0/4096.0;
+      prolongation[4](50,31) = -75.0/4096.0;
+      prolongation[4](50,32) = 135.0/4096.0;
+      prolongation[4](50,33) = -45.0/4096.0;
+      prolongation[4](50,34) = 135.0/4096.0;
+      prolongation[4](50,35) = -45.0/4096.0;
+      prolongation[4](50,36) = 675.0/4096.0;
+      prolongation[4](50,37) = -225.0/4096.0;
+      prolongation[4](50,38) = 675.0/4096.0;
+      prolongation[4](50,39) = -225.0/4096.0;
+      prolongation[4](50,40) = 75.0/4096.0;
+      prolongation[4](50,41) = -25.0/4096.0;
+      prolongation[4](50,42) = -225.0/4096.0;
+      prolongation[4](50,43) = 75.0/4096.0;
+      prolongation[4](50,44) = -45.0/4096.0;
+      prolongation[4](50,45) = 135.0/4096.0;
+      prolongation[4](50,46) = -45.0/4096.0;
+      prolongation[4](50,47) = 135.0/4096.0;
+      prolongation[4](50,48) = 75.0/4096.0;
+      prolongation[4](50,49) = -25.0/4096.0;
+      prolongation[4](50,50) = -225.0/4096.0;
+      prolongation[4](50,51) = 75.0/4096.0;
+      prolongation[4](50,52) = -225.0/4096.0;
+      prolongation[4](50,53) = 675.0/4096.0;
+      prolongation[4](50,54) = -225.0/4096.0;
+      prolongation[4](50,55) = 675.0/4096.0;
+      prolongation[4](50,56) = -675.0/4096.0;
+      prolongation[4](50,57) = 225.0/4096.0;
+      prolongation[4](50,58) = 2025.0/4096.0;
+      prolongation[4](50,59) = -675.0/4096.0;
+      prolongation[4](50,60) = -675.0/4096.0;
+      prolongation[4](50,61) = 225.0/4096.0;
+      prolongation[4](50,62) = 2025.0/4096.0;
+      prolongation[4](50,63) = -675.0/4096.0;
+      prolongation[4](51,8) = -1.0/256.0;
+      prolongation[4](51,12) = -1.0/256.0;
+      prolongation[4](51,16) = -5.0/256.0;
+      prolongation[4](51,20) = -5.0/256.0;
+      prolongation[4](51,32) = 9.0/256.0;
+      prolongation[4](51,34) = 9.0/256.0;
+      prolongation[4](51,36) = 45.0/256.0;
+      prolongation[4](51,38) = 45.0/256.0;
+      prolongation[4](51,40) = 5.0/256.0;
+      prolongation[4](51,42) = -15.0/256.0;
+      prolongation[4](51,48) = 5.0/256.0;
+      prolongation[4](51,50) = -15.0/256.0;
+      prolongation[4](51,56) = -45.0/256.0;
+      prolongation[4](51,58) = 135.0/256.0;
+      prolongation[4](51,60) = -45.0/256.0;
+      prolongation[4](51,62) = 135.0/256.0;
+      prolongation[4](52,25) = 5.0/16.0;
+      prolongation[4](52,31) = 1.0/16.0;
+      prolongation[4](52,53) = 15.0/16.0;
+      prolongation[4](52,55) = -5.0/16.0;
+      prolongation[4](53,0) = 5.0/256.0;
+      prolongation[4](53,3) = 1.0/256.0;
+      prolongation[4](53,4) = 25.0/256.0;
+      prolongation[4](53,7) = 5.0/256.0;
+      prolongation[4](53,14) = 15.0/256.0;
+      prolongation[4](53,15) = -5.0/256.0;
+      prolongation[4](53,22) = 75.0/256.0;
+      prolongation[4](53,23) = -25.0/256.0;
+      prolongation[4](53,24) = -25.0/256.0;
+      prolongation[4](53,25) = 75.0/256.0;
+      prolongation[4](53,30) = -5.0/256.0;
+      prolongation[4](53,31) = 15.0/256.0;
+      prolongation[4](53,52) = -75.0/256.0;
+      prolongation[4](53,53) = 225.0/256.0;
+      prolongation[4](53,54) = 25.0/256.0;
+      prolongation[4](53,55) = -75.0/256.0;
+      prolongation[4](54,53) = 1.0;
+      prolongation[4](55,14) = 1.0/16.0;
+      prolongation[4](55,22) = 5.0/16.0;
+      prolongation[4](55,52) = -5.0/16.0;
+      prolongation[4](55,53) = 15.0/16.0;
+      prolongation[4](56,25) = 25.0/256.0;
+      prolongation[4](56,27) = 5.0/256.0;
+      prolongation[4](56,29) = 1.0/256.0;
+      prolongation[4](56,31) = 5.0/256.0;
+      prolongation[4](56,42) = 75.0/256.0;
+      prolongation[4](56,43) = -25.0/256.0;
+      prolongation[4](56,45) = 15.0/256.0;
+      prolongation[4](56,47) = -5.0/256.0;
+      prolongation[4](56,50) = 15.0/256.0;
+      prolongation[4](56,51) = -5.0/256.0;
+      prolongation[4](56,53) = 75.0/256.0;
+      prolongation[4](56,55) = -25.0/256.0;
+      prolongation[4](56,58) = 225.0/256.0;
+      prolongation[4](56,59) = -75.0/256.0;
+      prolongation[4](56,62) = -75.0/256.0;
+      prolongation[4](56,63) = 25.0/256.0;
+      prolongation[4](57,42) = 5.0/16.0;
+      prolongation[4](57,50) = 1.0/16.0;
+      prolongation[4](57,58) = 15.0/16.0;
+      prolongation[4](57,62) = -5.0/16.0;
+      prolongation[4](58,0) = 25.0/4096.0;
+      prolongation[4](58,1) = 5.0/4096.0;
+      prolongation[4](58,2) = 1.0/4096.0;
+      prolongation[4](58,3) = 5.0/4096.0;
+      prolongation[4](58,4) = 125.0/4096.0;
+      prolongation[4](58,5) = 25.0/4096.0;
+      prolongation[4](58,6) = 5.0/4096.0;
+      prolongation[4](58,7) = 25.0/4096.0;
+      prolongation[4](58,8) = 75.0/4096.0;
+      prolongation[4](58,9) = -25.0/4096.0;
+      prolongation[4](58,10) = 15.0/4096.0;
+      prolongation[4](58,11) = -5.0/4096.0;
+      prolongation[4](58,12) = 15.0/4096.0;
+      prolongation[4](58,13) = -5.0/4096.0;
+      prolongation[4](58,14) = 75.0/4096.0;
+      prolongation[4](58,15) = -25.0/4096.0;
+      prolongation[4](58,16) = 375.0/4096.0;
+      prolongation[4](58,17) = -125.0/4096.0;
+      prolongation[4](58,18) = 75.0/4096.0;
+      prolongation[4](58,19) = -25.0/4096.0;
+      prolongation[4](58,20) = 75.0/4096.0;
+      prolongation[4](58,21) = -25.0/4096.0;
+      prolongation[4](58,22) = 375.0/4096.0;
+      prolongation[4](58,23) = -125.0/4096.0;
+      prolongation[4](58,24) = -125.0/4096.0;
+      prolongation[4](58,25) = 375.0/4096.0;
+      prolongation[4](58,26) = -25.0/4096.0;
+      prolongation[4](58,27) = 75.0/4096.0;
+      prolongation[4](58,28) = -5.0/4096.0;
+      prolongation[4](58,29) = 15.0/4096.0;
+      prolongation[4](58,30) = -25.0/4096.0;
+      prolongation[4](58,31) = 75.0/4096.0;
+      prolongation[4](58,32) = 225.0/4096.0;
+      prolongation[4](58,33) = -75.0/4096.0;
+      prolongation[4](58,34) = -75.0/4096.0;
+      prolongation[4](58,35) = 25.0/4096.0;
+      prolongation[4](58,36) = 1125.0/4096.0;
+      prolongation[4](58,37) = -375.0/4096.0;
+      prolongation[4](58,38) = -375.0/4096.0;
+      prolongation[4](58,39) = 125.0/4096.0;
+      prolongation[4](58,40) = -375.0/4096.0;
+      prolongation[4](58,41) = 125.0/4096.0;
+      prolongation[4](58,42) = 1125.0/4096.0;
+      prolongation[4](58,43) = -375.0/4096.0;
+      prolongation[4](58,44) = -75.0/4096.0;
+      prolongation[4](58,45) = 225.0/4096.0;
+      prolongation[4](58,46) = 25.0/4096.0;
+      prolongation[4](58,47) = -75.0/4096.0;
+      prolongation[4](58,48) = -75.0/4096.0;
+      prolongation[4](58,49) = 25.0/4096.0;
+      prolongation[4](58,50) = 225.0/4096.0;
+      prolongation[4](58,51) = -75.0/4096.0;
+      prolongation[4](58,52) = -375.0/4096.0;
+      prolongation[4](58,53) = 1125.0/4096.0;
+      prolongation[4](58,54) = 125.0/4096.0;
+      prolongation[4](58,55) = -375.0/4096.0;
+      prolongation[4](58,56) = -1125.0/4096.0;
+      prolongation[4](58,57) = 375.0/4096.0;
+      prolongation[4](58,58) = 3375.0/4096.0;
+      prolongation[4](58,59) = -1125.0/4096.0;
+      prolongation[4](58,60) = 375.0/4096.0;
+      prolongation[4](58,61) = -125.0/4096.0;
+      prolongation[4](58,62) = -1125.0/4096.0;
+      prolongation[4](58,63) = 375.0/4096.0;
+      prolongation[4](59,8) = 5.0/256.0;
+      prolongation[4](59,12) = 1.0/256.0;
+      prolongation[4](59,16) = 25.0/256.0;
+      prolongation[4](59,20) = 5.0/256.0;
+      prolongation[4](59,32) = 15.0/256.0;
+      prolongation[4](59,34) = -5.0/256.0;
+      prolongation[4](59,36) = 75.0/256.0;
+      prolongation[4](59,38) = -25.0/256.0;
+      prolongation[4](59,40) = -25.0/256.0;
+      prolongation[4](59,42) = 75.0/256.0;
+      prolongation[4](59,48) = -5.0/256.0;
+      prolongation[4](59,50) = 15.0/256.0;
+      prolongation[4](59,56) = -75.0/256.0;
+      prolongation[4](59,58) = 225.0/256.0;
+      prolongation[4](59,60) = 25.0/256.0;
+      prolongation[4](59,62) = -75.0/256.0;
+      prolongation[4](60,45) = 1.0/16.0;
+      prolongation[4](60,53) = 5.0/16.0;
+      prolongation[4](60,58) = 15.0/16.0;
+      prolongation[4](60,59) = -5.0/16.0;
+      prolongation[4](61,58) = 1.0;
+      prolongation[4](62,10) = 1.0/256.0;
+      prolongation[4](62,14) = 5.0/256.0;
+      prolongation[4](62,18) = 5.0/256.0;
+      prolongation[4](62,22) = 25.0/256.0;
+      prolongation[4](62,32) = 15.0/256.0;
+      prolongation[4](62,33) = -5.0/256.0;
+      prolongation[4](62,36) = 75.0/256.0;
+      prolongation[4](62,37) = -25.0/256.0;
+      prolongation[4](62,44) = -5.0/256.0;
+      prolongation[4](62,45) = 15.0/256.0;
+      prolongation[4](62,52) = -25.0/256.0;
+      prolongation[4](62,53) = 75.0/256.0;
+      prolongation[4](62,56) = -75.0/256.0;
+      prolongation[4](62,57) = 25.0/256.0;
+      prolongation[4](62,58) = 225.0/256.0;
+      prolongation[4](62,59) = -75.0/256.0;
+      prolongation[4](63,32) = 1.0/16.0;
+      prolongation[4](63,36) = 5.0/16.0;
+      prolongation[4](63,56) = -5.0/16.0;
+      prolongation[4](63,58) = 15.0/16.0;
+      prolongation[5](0,0) = 1.0/256.0;
+      prolongation[5](0,1) = 1.0/256.0;
+      prolongation[5](0,4) = 1.0/256.0;
+      prolongation[5](0,5) = 1.0/256.0;
+      prolongation[5](0,8) = -9.0/256.0;
+      prolongation[5](0,9) = -9.0/256.0;
+      prolongation[5](0,16) = -9.0/256.0;
+      prolongation[5](0,17) = -9.0/256.0;
+      prolongation[5](0,24) = -9.0/256.0;
+      prolongation[5](0,25) = -9.0/256.0;
+      prolongation[5](0,26) = -9.0/256.0;
+      prolongation[5](0,27) = -9.0/256.0;
+      prolongation[5](0,40) = 81.0/256.0;
+      prolongation[5](0,41) = 81.0/256.0;
+      prolongation[5](0,42) = 81.0/256.0;
+      prolongation[5](0,43) = 81.0/256.0;
+      prolongation[5](1,1) = -1.0/16.0;
+      prolongation[5](1,5) = -1.0/16.0;
+      prolongation[5](1,26) = 9.0/16.0;
+      prolongation[5](1,27) = 9.0/16.0;
+      prolongation[5](2,1) = 1.0/256.0;
+      prolongation[5](2,2) = 1.0/256.0;
+      prolongation[5](2,5) = 1.0/256.0;
+      prolongation[5](2,6) = 1.0/256.0;
+      prolongation[5](2,10) = -9.0/256.0;
+      prolongation[5](2,11) = -9.0/256.0;
+      prolongation[5](2,18) = -9.0/256.0;
+      prolongation[5](2,19) = -9.0/256.0;
+      prolongation[5](2,26) = -9.0/256.0;
+      prolongation[5](2,27) = -9.0/256.0;
+      prolongation[5](2,28) = -9.0/256.0;
+      prolongation[5](2,29) = -9.0/256.0;
+      prolongation[5](2,44) = 81.0/256.0;
+      prolongation[5](2,45) = 81.0/256.0;
+      prolongation[5](2,46) = 81.0/256.0;
+      prolongation[5](2,47) = 81.0/256.0;
+      prolongation[5](3,0) = -1.0/4096.0;
+      prolongation[5](3,1) = -1.0/4096.0;
+      prolongation[5](3,2) = -1.0/4096.0;
+      prolongation[5](3,3) = -1.0/4096.0;
+      prolongation[5](3,4) = -1.0/4096.0;
+      prolongation[5](3,5) = -1.0/4096.0;
+      prolongation[5](3,6) = -1.0/4096.0;
+      prolongation[5](3,7) = -1.0/4096.0;
+      prolongation[5](3,8) = 9.0/4096.0;
+      prolongation[5](3,9) = 9.0/4096.0;
+      prolongation[5](3,10) = 9.0/4096.0;
+      prolongation[5](3,11) = 9.0/4096.0;
+      prolongation[5](3,12) = 9.0/4096.0;
+      prolongation[5](3,13) = 9.0/4096.0;
+      prolongation[5](3,14) = 9.0/4096.0;
+      prolongation[5](3,15) = 9.0/4096.0;
+      prolongation[5](3,16) = 9.0/4096.0;
+      prolongation[5](3,17) = 9.0/4096.0;
+      prolongation[5](3,18) = 9.0/4096.0;
+      prolongation[5](3,19) = 9.0/4096.0;
+      prolongation[5](3,20) = 9.0/4096.0;
+      prolongation[5](3,21) = 9.0/4096.0;
+      prolongation[5](3,22) = 9.0/4096.0;
+      prolongation[5](3,23) = 9.0/4096.0;
+      prolongation[5](3,24) = 9.0/4096.0;
+      prolongation[5](3,25) = 9.0/4096.0;
+      prolongation[5](3,26) = 9.0/4096.0;
+      prolongation[5](3,27) = 9.0/4096.0;
+      prolongation[5](3,28) = 9.0/4096.0;
+      prolongation[5](3,29) = 9.0/4096.0;
+      prolongation[5](3,30) = 9.0/4096.0;
+      prolongation[5](3,31) = 9.0/4096.0;
+      prolongation[5](3,32) = -81.0/4096.0;
+      prolongation[5](3,33) = -81.0/4096.0;
+      prolongation[5](3,34) = -81.0/4096.0;
+      prolongation[5](3,35) = -81.0/4096.0;
+      prolongation[5](3,36) = -81.0/4096.0;
+      prolongation[5](3,37) = -81.0/4096.0;
+      prolongation[5](3,38) = -81.0/4096.0;
+      prolongation[5](3,39) = -81.0/4096.0;
+      prolongation[5](3,40) = -81.0/4096.0;
+      prolongation[5](3,41) = -81.0/4096.0;
+      prolongation[5](3,42) = -81.0/4096.0;
+      prolongation[5](3,43) = -81.0/4096.0;
+      prolongation[5](3,44) = -81.0/4096.0;
+      prolongation[5](3,45) = -81.0/4096.0;
+      prolongation[5](3,46) = -81.0/4096.0;
+      prolongation[5](3,47) = -81.0/4096.0;
+      prolongation[5](3,48) = -81.0/4096.0;
+      prolongation[5](3,49) = -81.0/4096.0;
+      prolongation[5](3,50) = -81.0/4096.0;
+      prolongation[5](3,51) = -81.0/4096.0;
+      prolongation[5](3,52) = -81.0/4096.0;
+      prolongation[5](3,53) = -81.0/4096.0;
+      prolongation[5](3,54) = -81.0/4096.0;
+      prolongation[5](3,55) = -81.0/4096.0;
+      prolongation[5](3,56) = 729.0/4096.0;
+      prolongation[5](3,57) = 729.0/4096.0;
+      prolongation[5](3,58) = 729.0/4096.0;
+      prolongation[5](3,59) = 729.0/4096.0;
+      prolongation[5](3,60) = 729.0/4096.0;
+      prolongation[5](3,61) = 729.0/4096.0;
+      prolongation[5](3,62) = 729.0/4096.0;
+      prolongation[5](3,63) = 729.0/4096.0;
+      prolongation[5](4,4) = -1.0/16.0;
+      prolongation[5](4,5) = -1.0/16.0;
+      prolongation[5](4,16) = 9.0/16.0;
+      prolongation[5](4,17) = 9.0/16.0;
+      prolongation[5](5,5) = 1.0;
+      prolongation[5](6,5) = -1.0/16.0;
+      prolongation[5](6,6) = -1.0/16.0;
+      prolongation[5](6,18) = 9.0/16.0;
+      prolongation[5](6,19) = 9.0/16.0;
+      prolongation[5](7,4) = 1.0/256.0;
+      prolongation[5](7,5) = 1.0/256.0;
+      prolongation[5](7,6) = 1.0/256.0;
+      prolongation[5](7,7) = 1.0/256.0;
+      prolongation[5](7,16) = -9.0/256.0;
+      prolongation[5](7,17) = -9.0/256.0;
+      prolongation[5](7,18) = -9.0/256.0;
+      prolongation[5](7,19) = -9.0/256.0;
+      prolongation[5](7,20) = -9.0/256.0;
+      prolongation[5](7,21) = -9.0/256.0;
+      prolongation[5](7,22) = -9.0/256.0;
+      prolongation[5](7,23) = -9.0/256.0;
+      prolongation[5](7,36) = 81.0/256.0;
+      prolongation[5](7,37) = 81.0/256.0;
+      prolongation[5](7,38) = 81.0/256.0;
+      prolongation[5](7,39) = 81.0/256.0;
+      prolongation[5](8,9) = -1.0/16.0;
+      prolongation[5](8,17) = -1.0/16.0;
+      prolongation[5](8,41) = 9.0/16.0;
+      prolongation[5](8,43) = 9.0/16.0;
+      prolongation[5](9,0) = -1.0/256.0;
+      prolongation[5](9,1) = -5.0/256.0;
+      prolongation[5](9,4) = -1.0/256.0;
+      prolongation[5](9,5) = -5.0/256.0;
+      prolongation[5](9,8) = 5.0/256.0;
+      prolongation[5](9,9) = -15.0/256.0;
+      prolongation[5](9,16) = 5.0/256.0;
+      prolongation[5](9,17) = -15.0/256.0;
+      prolongation[5](9,24) = 9.0/256.0;
+      prolongation[5](9,25) = 9.0/256.0;
+      prolongation[5](9,26) = 45.0/256.0;
+      prolongation[5](9,27) = 45.0/256.0;
+      prolongation[5](9,40) = -45.0/256.0;
+      prolongation[5](9,41) = 135.0/256.0;
+      prolongation[5](9,42) = -45.0/256.0;
+      prolongation[5](9,43) = 135.0/256.0;
+      prolongation[5](10,1) = -5.0/256.0;
+      prolongation[5](10,2) = -1.0/256.0;
+      prolongation[5](10,5) = -5.0/256.0;
+      prolongation[5](10,6) = -1.0/256.0;
+      prolongation[5](10,10) = -15.0/256.0;
+      prolongation[5](10,11) = 5.0/256.0;
+      prolongation[5](10,18) = -15.0/256.0;
+      prolongation[5](10,19) = 5.0/256.0;
+      prolongation[5](10,26) = 45.0/256.0;
+      prolongation[5](10,27) = 45.0/256.0;
+      prolongation[5](10,28) = 9.0/256.0;
+      prolongation[5](10,29) = 9.0/256.0;
+      prolongation[5](10,44) = 135.0/256.0;
+      prolongation[5](10,45) = 135.0/256.0;
+      prolongation[5](10,46) = -45.0/256.0;
+      prolongation[5](10,47) = -45.0/256.0;
+      prolongation[5](11,10) = -1.0/16.0;
+      prolongation[5](11,18) = -1.0/16.0;
+      prolongation[5](11,44) = 9.0/16.0;
+      prolongation[5](11,45) = 9.0/16.0;
+      prolongation[5](12,9) = 1.0/256.0;
+      prolongation[5](12,13) = 1.0/256.0;
+      prolongation[5](12,17) = 1.0/256.0;
+      prolongation[5](12,21) = 1.0/256.0;
+      prolongation[5](12,33) = -9.0/256.0;
+      prolongation[5](12,35) = -9.0/256.0;
+      prolongation[5](12,37) = -9.0/256.0;
+      prolongation[5](12,39) = -9.0/256.0;
+      prolongation[5](12,41) = -9.0/256.0;
+      prolongation[5](12,43) = -9.0/256.0;
+      prolongation[5](12,49) = -9.0/256.0;
+      prolongation[5](12,51) = -9.0/256.0;
+      prolongation[5](12,57) = 81.0/256.0;
+      prolongation[5](12,59) = 81.0/256.0;
+      prolongation[5](12,61) = 81.0/256.0;
+      prolongation[5](12,63) = 81.0/256.0;
+      prolongation[5](13,0) = 1.0/4096.0;
+      prolongation[5](13,1) = 5.0/4096.0;
+      prolongation[5](13,2) = 5.0/4096.0;
+      prolongation[5](13,3) = 1.0/4096.0;
+      prolongation[5](13,4) = 1.0/4096.0;
+      prolongation[5](13,5) = 5.0/4096.0;
+      prolongation[5](13,6) = 5.0/4096.0;
+      prolongation[5](13,7) = 1.0/4096.0;
+      prolongation[5](13,8) = -5.0/4096.0;
+      prolongation[5](13,9) = 15.0/4096.0;
+      prolongation[5](13,10) = -45.0/4096.0;
+      prolongation[5](13,11) = -45.0/4096.0;
+      prolongation[5](13,12) = -5.0/4096.0;
+      prolongation[5](13,13) = 15.0/4096.0;
+      prolongation[5](13,14) = -9.0/4096.0;
+      prolongation[5](13,15) = -9.0/4096.0;
+      prolongation[5](13,16) = -5.0/4096.0;
+      prolongation[5](13,17) = 15.0/4096.0;
+      prolongation[5](13,18) = -45.0/4096.0;
+      prolongation[5](13,19) = -45.0/4096.0;
+      prolongation[5](13,20) = -5.0/4096.0;
+      prolongation[5](13,21) = 15.0/4096.0;
+      prolongation[5](13,22) = -9.0/4096.0;
+      prolongation[5](13,23) = -9.0/4096.0;
+      prolongation[5](13,24) = -9.0/4096.0;
+      prolongation[5](13,25) = -9.0/4096.0;
+      prolongation[5](13,26) = -45.0/4096.0;
+      prolongation[5](13,27) = -45.0/4096.0;
+      prolongation[5](13,28) = -45.0/4096.0;
+      prolongation[5](13,29) = -45.0/4096.0;
+      prolongation[5](13,30) = -9.0/4096.0;
+      prolongation[5](13,31) = -9.0/4096.0;
+      prolongation[5](13,32) = 45.0/4096.0;
+      prolongation[5](13,33) = -135.0/4096.0;
+      prolongation[5](13,34) = 45.0/4096.0;
+      prolongation[5](13,35) = -135.0/4096.0;
+      prolongation[5](13,36) = 45.0/4096.0;
+      prolongation[5](13,37) = -135.0/4096.0;
+      prolongation[5](13,38) = 45.0/4096.0;
+      prolongation[5](13,39) = -135.0/4096.0;
+      prolongation[5](13,40) = 45.0/4096.0;
+      prolongation[5](13,41) = -135.0/4096.0;
+      prolongation[5](13,42) = 45.0/4096.0;
+      prolongation[5](13,43) = -135.0/4096.0;
+      prolongation[5](13,44) = 405.0/4096.0;
+      prolongation[5](13,45) = 405.0/4096.0;
+      prolongation[5](13,46) = 405.0/4096.0;
+      prolongation[5](13,47) = 405.0/4096.0;
+      prolongation[5](13,48) = 45.0/4096.0;
+      prolongation[5](13,49) = -135.0/4096.0;
+      prolongation[5](13,50) = 45.0/4096.0;
+      prolongation[5](13,51) = -135.0/4096.0;
+      prolongation[5](13,52) = 81.0/4096.0;
+      prolongation[5](13,53) = 81.0/4096.0;
+      prolongation[5](13,54) = 81.0/4096.0;
+      prolongation[5](13,55) = 81.0/4096.0;
+      prolongation[5](13,56) = -405.0/4096.0;
+      prolongation[5](13,57) = 1215.0/4096.0;
+      prolongation[5](13,58) = -405.0/4096.0;
+      prolongation[5](13,59) = 1215.0/4096.0;
+      prolongation[5](13,60) = -405.0/4096.0;
+      prolongation[5](13,61) = 1215.0/4096.0;
+      prolongation[5](13,62) = -405.0/4096.0;
+      prolongation[5](13,63) = 1215.0/4096.0;
+      prolongation[5](14,0) = 5.0/4096.0;
+      prolongation[5](14,1) = 5.0/4096.0;
+      prolongation[5](14,2) = 1.0/4096.0;
+      prolongation[5](14,3) = 1.0/4096.0;
+      prolongation[5](14,4) = 5.0/4096.0;
+      prolongation[5](14,5) = 5.0/4096.0;
+      prolongation[5](14,6) = 1.0/4096.0;
+      prolongation[5](14,7) = 1.0/4096.0;
+      prolongation[5](14,8) = -45.0/4096.0;
+      prolongation[5](14,9) = -45.0/4096.0;
+      prolongation[5](14,10) = 15.0/4096.0;
+      prolongation[5](14,11) = -5.0/4096.0;
+      prolongation[5](14,12) = -9.0/4096.0;
+      prolongation[5](14,13) = -9.0/4096.0;
+      prolongation[5](14,14) = 15.0/4096.0;
+      prolongation[5](14,15) = -5.0/4096.0;
+      prolongation[5](14,16) = -45.0/4096.0;
+      prolongation[5](14,17) = -45.0/4096.0;
+      prolongation[5](14,18) = 15.0/4096.0;
+      prolongation[5](14,19) = -5.0/4096.0;
+      prolongation[5](14,20) = -9.0/4096.0;
+      prolongation[5](14,21) = -9.0/4096.0;
+      prolongation[5](14,22) = 15.0/4096.0;
+      prolongation[5](14,23) = -5.0/4096.0;
+      prolongation[5](14,24) = -45.0/4096.0;
+      prolongation[5](14,25) = -45.0/4096.0;
+      prolongation[5](14,26) = -45.0/4096.0;
+      prolongation[5](14,27) = -45.0/4096.0;
+      prolongation[5](14,28) = -9.0/4096.0;
+      prolongation[5](14,29) = -9.0/4096.0;
+      prolongation[5](14,30) = -9.0/4096.0;
+      prolongation[5](14,31) = -9.0/4096.0;
+      prolongation[5](14,32) = -135.0/4096.0;
+      prolongation[5](14,33) = -135.0/4096.0;
+      prolongation[5](14,34) = 45.0/4096.0;
+      prolongation[5](14,35) = 45.0/4096.0;
+      prolongation[5](14,36) = -135.0/4096.0;
+      prolongation[5](14,37) = -135.0/4096.0;
+      prolongation[5](14,38) = 45.0/4096.0;
+      prolongation[5](14,39) = 45.0/4096.0;
+      prolongation[5](14,40) = 405.0/4096.0;
+      prolongation[5](14,41) = 405.0/4096.0;
+      prolongation[5](14,42) = 405.0/4096.0;
+      prolongation[5](14,43) = 405.0/4096.0;
+      prolongation[5](14,44) = -135.0/4096.0;
+      prolongation[5](14,45) = -135.0/4096.0;
+      prolongation[5](14,46) = 45.0/4096.0;
+      prolongation[5](14,47) = 45.0/4096.0;
+      prolongation[5](14,48) = 81.0/4096.0;
+      prolongation[5](14,49) = 81.0/4096.0;
+      prolongation[5](14,50) = 81.0/4096.0;
+      prolongation[5](14,51) = 81.0/4096.0;
+      prolongation[5](14,52) = -135.0/4096.0;
+      prolongation[5](14,53) = -135.0/4096.0;
+      prolongation[5](14,54) = 45.0/4096.0;
+      prolongation[5](14,55) = 45.0/4096.0;
+      prolongation[5](14,56) = 1215.0/4096.0;
+      prolongation[5](14,57) = 1215.0/4096.0;
+      prolongation[5](14,58) = 1215.0/4096.0;
+      prolongation[5](14,59) = 1215.0/4096.0;
+      prolongation[5](14,60) = -405.0/4096.0;
+      prolongation[5](14,61) = -405.0/4096.0;
+      prolongation[5](14,62) = -405.0/4096.0;
+      prolongation[5](14,63) = -405.0/4096.0;
+      prolongation[5](15,10) = 1.0/256.0;
+      prolongation[5](15,14) = 1.0/256.0;
+      prolongation[5](15,18) = 1.0/256.0;
+      prolongation[5](15,22) = 1.0/256.0;
+      prolongation[5](15,32) = -9.0/256.0;
+      prolongation[5](15,33) = -9.0/256.0;
+      prolongation[5](15,36) = -9.0/256.0;
+      prolongation[5](15,37) = -9.0/256.0;
+      prolongation[5](15,44) = -9.0/256.0;
+      prolongation[5](15,45) = -9.0/256.0;
+      prolongation[5](15,52) = -9.0/256.0;
+      prolongation[5](15,53) = -9.0/256.0;
+      prolongation[5](15,56) = 81.0/256.0;
+      prolongation[5](15,57) = 81.0/256.0;
+      prolongation[5](15,58) = 81.0/256.0;
+      prolongation[5](15,59) = 81.0/256.0;
+      prolongation[5](16,17) = 1.0;
+      prolongation[5](17,4) = 1.0/16.0;
+      prolongation[5](17,5) = 5.0/16.0;
+      prolongation[5](17,16) = -5.0/16.0;
+      prolongation[5](17,17) = 15.0/16.0;
+      prolongation[5](18,5) = 5.0/16.0;
+      prolongation[5](18,6) = 1.0/16.0;
+      prolongation[5](18,18) = 15.0/16.0;
+      prolongation[5](18,19) = -5.0/16.0;
+      prolongation[5](19,18) = 1.0;
+      prolongation[5](20,17) = -1.0/16.0;
+      prolongation[5](20,21) = -1.0/16.0;
+      prolongation[5](20,37) = 9.0/16.0;
+      prolongation[5](20,39) = 9.0/16.0;
+      prolongation[5](21,4) = -1.0/256.0;
+      prolongation[5](21,5) = -5.0/256.0;
+      prolongation[5](21,6) = -5.0/256.0;
+      prolongation[5](21,7) = -1.0/256.0;
+      prolongation[5](21,16) = 5.0/256.0;
+      prolongation[5](21,17) = -15.0/256.0;
+      prolongation[5](21,18) = 45.0/256.0;
+      prolongation[5](21,19) = 45.0/256.0;
+      prolongation[5](21,20) = 5.0/256.0;
+      prolongation[5](21,21) = -15.0/256.0;
+      prolongation[5](21,22) = 9.0/256.0;
+      prolongation[5](21,23) = 9.0/256.0;
+      prolongation[5](21,36) = -45.0/256.0;
+      prolongation[5](21,37) = 135.0/256.0;
+      prolongation[5](21,38) = -45.0/256.0;
+      prolongation[5](21,39) = 135.0/256.0;
+      prolongation[5](22,4) = -5.0/256.0;
+      prolongation[5](22,5) = -5.0/256.0;
+      prolongation[5](22,6) = -1.0/256.0;
+      prolongation[5](22,7) = -1.0/256.0;
+      prolongation[5](22,16) = 45.0/256.0;
+      prolongation[5](22,17) = 45.0/256.0;
+      prolongation[5](22,18) = -15.0/256.0;
+      prolongation[5](22,19) = 5.0/256.0;
+      prolongation[5](22,20) = 9.0/256.0;
+      prolongation[5](22,21) = 9.0/256.0;
+      prolongation[5](22,22) = -15.0/256.0;
+      prolongation[5](22,23) = 5.0/256.0;
+      prolongation[5](22,36) = 135.0/256.0;
+      prolongation[5](22,37) = 135.0/256.0;
+      prolongation[5](22,38) = -45.0/256.0;
+      prolongation[5](22,39) = -45.0/256.0;
+      prolongation[5](23,18) = -1.0/16.0;
+      prolongation[5](23,22) = -1.0/16.0;
+      prolongation[5](23,36) = 9.0/16.0;
+      prolongation[5](23,37) = 9.0/16.0;
+      prolongation[5](24,25) = -1.0/16.0;
+      prolongation[5](24,27) = -1.0/16.0;
+      prolongation[5](24,42) = 9.0/16.0;
+      prolongation[5](24,43) = 9.0/16.0;
+      prolongation[5](25,0) = -1.0/256.0;
+      prolongation[5](25,1) = -1.0/256.0;
+      prolongation[5](25,4) = -5.0/256.0;
+      prolongation[5](25,5) = -5.0/256.0;
+      prolongation[5](25,8) = 9.0/256.0;
+      prolongation[5](25,9) = 9.0/256.0;
+      prolongation[5](25,16) = 45.0/256.0;
+      prolongation[5](25,17) = 45.0/256.0;
+      prolongation[5](25,24) = 5.0/256.0;
+      prolongation[5](25,25) = -15.0/256.0;
+      prolongation[5](25,26) = 5.0/256.0;
+      prolongation[5](25,27) = -15.0/256.0;
+      prolongation[5](25,40) = -45.0/256.0;
+      prolongation[5](25,41) = -45.0/256.0;
+      prolongation[5](25,42) = 135.0/256.0;
+      prolongation[5](25,43) = 135.0/256.0;
+      prolongation[5](26,27) = 1.0;
+      prolongation[5](27,1) = 1.0/16.0;
+      prolongation[5](27,5) = 5.0/16.0;
+      prolongation[5](27,26) = -5.0/16.0;
+      prolongation[5](27,27) = 15.0/16.0;
+      prolongation[5](28,27) = -1.0/16.0;
+      prolongation[5](28,29) = -1.0/16.0;
+      prolongation[5](28,45) = 9.0/16.0;
+      prolongation[5](28,47) = 9.0/16.0;
+      prolongation[5](29,1) = -1.0/256.0;
+      prolongation[5](29,2) = -1.0/256.0;
+      prolongation[5](29,5) = -5.0/256.0;
+      prolongation[5](29,6) = -5.0/256.0;
+      prolongation[5](29,10) = 9.0/256.0;
+      prolongation[5](29,11) = 9.0/256.0;
+      prolongation[5](29,18) = 45.0/256.0;
+      prolongation[5](29,19) = 45.0/256.0;
+      prolongation[5](29,26) = 5.0/256.0;
+      prolongation[5](29,27) = -15.0/256.0;
+      prolongation[5](29,28) = 5.0/256.0;
+      prolongation[5](29,29) = -15.0/256.0;
+      prolongation[5](29,44) = -45.0/256.0;
+      prolongation[5](29,45) = 135.0/256.0;
+      prolongation[5](29,46) = -45.0/256.0;
+      prolongation[5](29,47) = 135.0/256.0;
+      prolongation[5](30,25) = 1.0/256.0;
+      prolongation[5](30,27) = 1.0/256.0;
+      prolongation[5](30,29) = 1.0/256.0;
+      prolongation[5](30,31) = 1.0/256.0;
+      prolongation[5](30,42) = -9.0/256.0;
+      prolongation[5](30,43) = -9.0/256.0;
+      prolongation[5](30,45) = -9.0/256.0;
+      prolongation[5](30,47) = -9.0/256.0;
+      prolongation[5](30,50) = -9.0/256.0;
+      prolongation[5](30,51) = -9.0/256.0;
+      prolongation[5](30,53) = -9.0/256.0;
+      prolongation[5](30,55) = -9.0/256.0;
+      prolongation[5](30,58) = 81.0/256.0;
+      prolongation[5](30,59) = 81.0/256.0;
+      prolongation[5](30,62) = 81.0/256.0;
+      prolongation[5](30,63) = 81.0/256.0;
+      prolongation[5](31,0) = 1.0/4096.0;
+      prolongation[5](31,1) = 1.0/4096.0;
+      prolongation[5](31,2) = 1.0/4096.0;
+      prolongation[5](31,3) = 1.0/4096.0;
+      prolongation[5](31,4) = 5.0/4096.0;
+      prolongation[5](31,5) = 5.0/4096.0;
+      prolongation[5](31,6) = 5.0/4096.0;
+      prolongation[5](31,7) = 5.0/4096.0;
+      prolongation[5](31,8) = -9.0/4096.0;
+      prolongation[5](31,9) = -9.0/4096.0;
+      prolongation[5](31,10) = -9.0/4096.0;
+      prolongation[5](31,11) = -9.0/4096.0;
+      prolongation[5](31,12) = -9.0/4096.0;
+      prolongation[5](31,13) = -9.0/4096.0;
+      prolongation[5](31,14) = -9.0/4096.0;
+      prolongation[5](31,15) = -9.0/4096.0;
+      prolongation[5](31,16) = -45.0/4096.0;
+      prolongation[5](31,17) = -45.0/4096.0;
+      prolongation[5](31,18) = -45.0/4096.0;
+      prolongation[5](31,19) = -45.0/4096.0;
+      prolongation[5](31,20) = -45.0/4096.0;
+      prolongation[5](31,21) = -45.0/4096.0;
+      prolongation[5](31,22) = -45.0/4096.0;
+      prolongation[5](31,23) = -45.0/4096.0;
+      prolongation[5](31,24) = -5.0/4096.0;
+      prolongation[5](31,25) = 15.0/4096.0;
+      prolongation[5](31,26) = -5.0/4096.0;
+      prolongation[5](31,27) = 15.0/4096.0;
+      prolongation[5](31,28) = -5.0/4096.0;
+      prolongation[5](31,29) = 15.0/4096.0;
+      prolongation[5](31,30) = -5.0/4096.0;
+      prolongation[5](31,31) = 15.0/4096.0;
+      prolongation[5](31,32) = 81.0/4096.0;
+      prolongation[5](31,33) = 81.0/4096.0;
+      prolongation[5](31,34) = 81.0/4096.0;
+      prolongation[5](31,35) = 81.0/4096.0;
+      prolongation[5](31,36) = 405.0/4096.0;
+      prolongation[5](31,37) = 405.0/4096.0;
+      prolongation[5](31,38) = 405.0/4096.0;
+      prolongation[5](31,39) = 405.0/4096.0;
+      prolongation[5](31,40) = 45.0/4096.0;
+      prolongation[5](31,41) = 45.0/4096.0;
+      prolongation[5](31,42) = -135.0/4096.0;
+      prolongation[5](31,43) = -135.0/4096.0;
+      prolongation[5](31,44) = 45.0/4096.0;
+      prolongation[5](31,45) = -135.0/4096.0;
+      prolongation[5](31,46) = 45.0/4096.0;
+      prolongation[5](31,47) = -135.0/4096.0;
+      prolongation[5](31,48) = 45.0/4096.0;
+      prolongation[5](31,49) = 45.0/4096.0;
+      prolongation[5](31,50) = -135.0/4096.0;
+      prolongation[5](31,51) = -135.0/4096.0;
+      prolongation[5](31,52) = 45.0/4096.0;
+      prolongation[5](31,53) = -135.0/4096.0;
+      prolongation[5](31,54) = 45.0/4096.0;
+      prolongation[5](31,55) = -135.0/4096.0;
+      prolongation[5](31,56) = -405.0/4096.0;
+      prolongation[5](31,57) = -405.0/4096.0;
+      prolongation[5](31,58) = 1215.0/4096.0;
+      prolongation[5](31,59) = 1215.0/4096.0;
+      prolongation[5](31,60) = -405.0/4096.0;
+      prolongation[5](31,61) = -405.0/4096.0;
+      prolongation[5](31,62) = 1215.0/4096.0;
+      prolongation[5](31,63) = 1215.0/4096.0;
+      prolongation[5](32,9) = -5.0/256.0;
+      prolongation[5](32,13) = -1.0/256.0;
+      prolongation[5](32,17) = -5.0/256.0;
+      prolongation[5](32,21) = -1.0/256.0;
+      prolongation[5](32,33) = -15.0/256.0;
+      prolongation[5](32,35) = 5.0/256.0;
+      prolongation[5](32,37) = -15.0/256.0;
+      prolongation[5](32,39) = 5.0/256.0;
+      prolongation[5](32,41) = 45.0/256.0;
+      prolongation[5](32,43) = 45.0/256.0;
+      prolongation[5](32,49) = 9.0/256.0;
+      prolongation[5](32,51) = 9.0/256.0;
+      prolongation[5](32,57) = 135.0/256.0;
+      prolongation[5](32,59) = 135.0/256.0;
+      prolongation[5](32,61) = -45.0/256.0;
+      prolongation[5](32,63) = -45.0/256.0;
+      prolongation[5](33,0) = -5.0/4096.0;
+      prolongation[5](33,1) = -25.0/4096.0;
+      prolongation[5](33,2) = -5.0/4096.0;
+      prolongation[5](33,3) = -1.0/4096.0;
+      prolongation[5](33,4) = -5.0/4096.0;
+      prolongation[5](33,5) = -25.0/4096.0;
+      prolongation[5](33,6) = -5.0/4096.0;
+      prolongation[5](33,7) = -1.0/4096.0;
+      prolongation[5](33,8) = 25.0/4096.0;
+      prolongation[5](33,9) = -75.0/4096.0;
+      prolongation[5](33,10) = -75.0/4096.0;
+      prolongation[5](33,11) = 25.0/4096.0;
+      prolongation[5](33,12) = 5.0/4096.0;
+      prolongation[5](33,13) = -15.0/4096.0;
+      prolongation[5](33,14) = -15.0/4096.0;
+      prolongation[5](33,15) = 5.0/4096.0;
+      prolongation[5](33,16) = 25.0/4096.0;
+      prolongation[5](33,17) = -75.0/4096.0;
+      prolongation[5](33,18) = -75.0/4096.0;
+      prolongation[5](33,19) = 25.0/4096.0;
+      prolongation[5](33,20) = 5.0/4096.0;
+      prolongation[5](33,21) = -15.0/4096.0;
+      prolongation[5](33,22) = -15.0/4096.0;
+      prolongation[5](33,23) = 5.0/4096.0;
+      prolongation[5](33,24) = 45.0/4096.0;
+      prolongation[5](33,25) = 45.0/4096.0;
+      prolongation[5](33,26) = 225.0/4096.0;
+      prolongation[5](33,27) = 225.0/4096.0;
+      prolongation[5](33,28) = 45.0/4096.0;
+      prolongation[5](33,29) = 45.0/4096.0;
+      prolongation[5](33,30) = 9.0/4096.0;
+      prolongation[5](33,31) = 9.0/4096.0;
+      prolongation[5](33,32) = 75.0/4096.0;
+      prolongation[5](33,33) = -225.0/4096.0;
+      prolongation[5](33,34) = -25.0/4096.0;
+      prolongation[5](33,35) = 75.0/4096.0;
+      prolongation[5](33,36) = 75.0/4096.0;
+      prolongation[5](33,37) = -225.0/4096.0;
+      prolongation[5](33,38) = -25.0/4096.0;
+      prolongation[5](33,39) = 75.0/4096.0;
+      prolongation[5](33,40) = -225.0/4096.0;
+      prolongation[5](33,41) = 675.0/4096.0;
+      prolongation[5](33,42) = -225.0/4096.0;
+      prolongation[5](33,43) = 675.0/4096.0;
+      prolongation[5](33,44) = 675.0/4096.0;
+      prolongation[5](33,45) = 675.0/4096.0;
+      prolongation[5](33,46) = -225.0/4096.0;
+      prolongation[5](33,47) = -225.0/4096.0;
+      prolongation[5](33,48) = -45.0/4096.0;
+      prolongation[5](33,49) = 135.0/4096.0;
+      prolongation[5](33,50) = -45.0/4096.0;
+      prolongation[5](33,51) = 135.0/4096.0;
+      prolongation[5](33,52) = 135.0/4096.0;
+      prolongation[5](33,53) = 135.0/4096.0;
+      prolongation[5](33,54) = -45.0/4096.0;
+      prolongation[5](33,55) = -45.0/4096.0;
+      prolongation[5](33,56) = -675.0/4096.0;
+      prolongation[5](33,57) = 2025.0/4096.0;
+      prolongation[5](33,58) = -675.0/4096.0;
+      prolongation[5](33,59) = 2025.0/4096.0;
+      prolongation[5](33,60) = 225.0/4096.0;
+      prolongation[5](33,61) = -675.0/4096.0;
+      prolongation[5](33,62) = 225.0/4096.0;
+      prolongation[5](33,63) = -675.0/4096.0;
+      prolongation[5](34,33) = -1.0/16.0;
+      prolongation[5](34,37) = -1.0/16.0;
+      prolongation[5](34,57) = 9.0/16.0;
+      prolongation[5](34,59) = 9.0/16.0;
+      prolongation[5](35,10) = -5.0/256.0;
+      prolongation[5](35,14) = -1.0/256.0;
+      prolongation[5](35,18) = -5.0/256.0;
+      prolongation[5](35,22) = -1.0/256.0;
+      prolongation[5](35,32) = 5.0/256.0;
+      prolongation[5](35,33) = -15.0/256.0;
+      prolongation[5](35,36) = 5.0/256.0;
+      prolongation[5](35,37) = -15.0/256.0;
+      prolongation[5](35,44) = 45.0/256.0;
+      prolongation[5](35,45) = 45.0/256.0;
+      prolongation[5](35,52) = 9.0/256.0;
+      prolongation[5](35,53) = 9.0/256.0;
+      prolongation[5](35,56) = -45.0/256.0;
+      prolongation[5](35,57) = 135.0/256.0;
+      prolongation[5](35,58) = -45.0/256.0;
+      prolongation[5](35,59) = 135.0/256.0;
+      prolongation[5](36,17) = 5.0/16.0;
+      prolongation[5](36,21) = 1.0/16.0;
+      prolongation[5](36,37) = 15.0/16.0;
+      prolongation[5](36,39) = -5.0/16.0;
+      prolongation[5](37,4) = 5.0/256.0;
+      prolongation[5](37,5) = 25.0/256.0;
+      prolongation[5](37,6) = 5.0/256.0;
+      prolongation[5](37,7) = 1.0/256.0;
+      prolongation[5](37,16) = -25.0/256.0;
+      prolongation[5](37,17) = 75.0/256.0;
+      prolongation[5](37,18) = 75.0/256.0;
+      prolongation[5](37,19) = -25.0/256.0;
+      prolongation[5](37,20) = -5.0/256.0;
+      prolongation[5](37,21) = 15.0/256.0;
+      prolongation[5](37,22) = 15.0/256.0;
+      prolongation[5](37,23) = -5.0/256.0;
+      prolongation[5](37,36) = -75.0/256.0;
+      prolongation[5](37,37) = 225.0/256.0;
+      prolongation[5](37,38) = 25.0/256.0;
+      prolongation[5](37,39) = -75.0/256.0;
+      prolongation[5](38,37) = 1.0;
+      prolongation[5](39,18) = 5.0/16.0;
+      prolongation[5](39,22) = 1.0/16.0;
+      prolongation[5](39,36) = -5.0/16.0;
+      prolongation[5](39,37) = 15.0/16.0;
+      prolongation[5](40,43) = 1.0;
+      prolongation[5](41,25) = 1.0/16.0;
+      prolongation[5](41,27) = 5.0/16.0;
+      prolongation[5](41,42) = -5.0/16.0;
+      prolongation[5](41,43) = 15.0/16.0;
+      prolongation[5](42,9) = 1.0/16.0;
+      prolongation[5](42,17) = 5.0/16.0;
+      prolongation[5](42,41) = -5.0/16.0;
+      prolongation[5](42,43) = 15.0/16.0;
+      prolongation[5](43,0) = 1.0/256.0;
+      prolongation[5](43,1) = 5.0/256.0;
+      prolongation[5](43,4) = 5.0/256.0;
+      prolongation[5](43,5) = 25.0/256.0;
+      prolongation[5](43,8) = -5.0/256.0;
+      prolongation[5](43,9) = 15.0/256.0;
+      prolongation[5](43,16) = -25.0/256.0;
+      prolongation[5](43,17) = 75.0/256.0;
+      prolongation[5](43,24) = -5.0/256.0;
+      prolongation[5](43,25) = 15.0/256.0;
+      prolongation[5](43,26) = -25.0/256.0;
+      prolongation[5](43,27) = 75.0/256.0;
+      prolongation[5](43,40) = 25.0/256.0;
+      prolongation[5](43,41) = -75.0/256.0;
+      prolongation[5](43,42) = -75.0/256.0;
+      prolongation[5](43,43) = 225.0/256.0;
+      prolongation[5](44,27) = 5.0/16.0;
+      prolongation[5](44,29) = 1.0/16.0;
+      prolongation[5](44,45) = 15.0/16.0;
+      prolongation[5](44,47) = -5.0/16.0;
+      prolongation[5](45,1) = 5.0/256.0;
+      prolongation[5](45,2) = 1.0/256.0;
+      prolongation[5](45,5) = 25.0/256.0;
+      prolongation[5](45,6) = 5.0/256.0;
+      prolongation[5](45,10) = 15.0/256.0;
+      prolongation[5](45,11) = -5.0/256.0;
+      prolongation[5](45,18) = 75.0/256.0;
+      prolongation[5](45,19) = -25.0/256.0;
+      prolongation[5](45,26) = -25.0/256.0;
+      prolongation[5](45,27) = 75.0/256.0;
+      prolongation[5](45,28) = -5.0/256.0;
+      prolongation[5](45,29) = 15.0/256.0;
+      prolongation[5](45,44) = -75.0/256.0;
+      prolongation[5](45,45) = 225.0/256.0;
+      prolongation[5](45,46) = 25.0/256.0;
+      prolongation[5](45,47) = -75.0/256.0;
+      prolongation[5](46,45) = 1.0;
+      prolongation[5](47,10) = 1.0/16.0;
+      prolongation[5](47,18) = 5.0/16.0;
+      prolongation[5](47,44) = -5.0/16.0;
+      prolongation[5](47,45) = 15.0/16.0;
+      prolongation[5](48,43) = -1.0/16.0;
+      prolongation[5](48,51) = -1.0/16.0;
+      prolongation[5](48,59) = 9.0/16.0;
+      prolongation[5](48,63) = 9.0/16.0;
+      prolongation[5](49,25) = -1.0/256.0;
+      prolongation[5](49,27) = -5.0/256.0;
+      prolongation[5](49,29) = -5.0/256.0;
+      prolongation[5](49,31) = -1.0/256.0;
+      prolongation[5](49,42) = 5.0/256.0;
+      prolongation[5](49,43) = -15.0/256.0;
+      prolongation[5](49,45) = 45.0/256.0;
+      prolongation[5](49,47) = 45.0/256.0;
+      prolongation[5](49,50) = 5.0/256.0;
+      prolongation[5](49,51) = -15.0/256.0;
+      prolongation[5](49,53) = 9.0/256.0;
+      prolongation[5](49,55) = 9.0/256.0;
+      prolongation[5](49,58) = -45.0/256.0;
+      prolongation[5](49,59) = 135.0/256.0;
+      prolongation[5](49,62) = -45.0/256.0;
+      prolongation[5](49,63) = 135.0/256.0;
+      prolongation[5](50,9) = -1.0/256.0;
+      prolongation[5](50,13) = -1.0/256.0;
+      prolongation[5](50,17) = -5.0/256.0;
+      prolongation[5](50,21) = -5.0/256.0;
+      prolongation[5](50,33) = 9.0/256.0;
+      prolongation[5](50,35) = 9.0/256.0;
+      prolongation[5](50,37) = 45.0/256.0;
+      prolongation[5](50,39) = 45.0/256.0;
+      prolongation[5](50,41) = 5.0/256.0;
+      prolongation[5](50,43) = -15.0/256.0;
+      prolongation[5](50,49) = 5.0/256.0;
+      prolongation[5](50,51) = -15.0/256.0;
+      prolongation[5](50,57) = -45.0/256.0;
+      prolongation[5](50,59) = 135.0/256.0;
+      prolongation[5](50,61) = -45.0/256.0;
+      prolongation[5](50,63) = 135.0/256.0;
+      prolongation[5](51,0) = -1.0/4096.0;
+      prolongation[5](51,1) = -5.0/4096.0;
+      prolongation[5](51,2) = -5.0/4096.0;
+      prolongation[5](51,3) = -1.0/4096.0;
+      prolongation[5](51,4) = -5.0/4096.0;
+      prolongation[5](51,5) = -25.0/4096.0;
+      prolongation[5](51,6) = -25.0/4096.0;
+      prolongation[5](51,7) = -5.0/4096.0;
+      prolongation[5](51,8) = 5.0/4096.0;
+      prolongation[5](51,9) = -15.0/4096.0;
+      prolongation[5](51,10) = 45.0/4096.0;
+      prolongation[5](51,11) = 45.0/4096.0;
+      prolongation[5](51,12) = 5.0/4096.0;
+      prolongation[5](51,13) = -15.0/4096.0;
+      prolongation[5](51,14) = 9.0/4096.0;
+      prolongation[5](51,15) = 9.0/4096.0;
+      prolongation[5](51,16) = 25.0/4096.0;
+      prolongation[5](51,17) = -75.0/4096.0;
+      prolongation[5](51,18) = 225.0/4096.0;
+      prolongation[5](51,19) = 225.0/4096.0;
+      prolongation[5](51,20) = 25.0/4096.0;
+      prolongation[5](51,21) = -75.0/4096.0;
+      prolongation[5](51,22) = 45.0/4096.0;
+      prolongation[5](51,23) = 45.0/4096.0;
+      prolongation[5](51,24) = 5.0/4096.0;
+      prolongation[5](51,25) = -15.0/4096.0;
+      prolongation[5](51,26) = 25.0/4096.0;
+      prolongation[5](51,27) = -75.0/4096.0;
+      prolongation[5](51,28) = 25.0/4096.0;
+      prolongation[5](51,29) = -75.0/4096.0;
+      prolongation[5](51,30) = 5.0/4096.0;
+      prolongation[5](51,31) = -15.0/4096.0;
+      prolongation[5](51,32) = -45.0/4096.0;
+      prolongation[5](51,33) = 135.0/4096.0;
+      prolongation[5](51,34) = -45.0/4096.0;
+      prolongation[5](51,35) = 135.0/4096.0;
+      prolongation[5](51,36) = -225.0/4096.0;
+      prolongation[5](51,37) = 675.0/4096.0;
+      prolongation[5](51,38) = -225.0/4096.0;
+      prolongation[5](51,39) = 675.0/4096.0;
+      prolongation[5](51,40) = -25.0/4096.0;
+      prolongation[5](51,41) = 75.0/4096.0;
+      prolongation[5](51,42) = 75.0/4096.0;
+      prolongation[5](51,43) = -225.0/4096.0;
+      prolongation[5](51,44) = -225.0/4096.0;
+      prolongation[5](51,45) = 675.0/4096.0;
+      prolongation[5](51,46) = -225.0/4096.0;
+      prolongation[5](51,47) = 675.0/4096.0;
+      prolongation[5](51,48) = -25.0/4096.0;
+      prolongation[5](51,49) = 75.0/4096.0;
+      prolongation[5](51,50) = 75.0/4096.0;
+      prolongation[5](51,51) = -225.0/4096.0;
+      prolongation[5](51,52) = -45.0/4096.0;
+      prolongation[5](51,53) = 135.0/4096.0;
+      prolongation[5](51,54) = -45.0/4096.0;
+      prolongation[5](51,55) = 135.0/4096.0;
+      prolongation[5](51,56) = 225.0/4096.0;
+      prolongation[5](51,57) = -675.0/4096.0;
+      prolongation[5](51,58) = -675.0/4096.0;
+      prolongation[5](51,59) = 2025.0/4096.0;
+      prolongation[5](51,60) = 225.0/4096.0;
+      prolongation[5](51,61) = -675.0/4096.0;
+      prolongation[5](51,62) = -675.0/4096.0;
+      prolongation[5](51,63) = 2025.0/4096.0;
+      prolongation[5](52,25) = -5.0/256.0;
+      prolongation[5](52,27) = -5.0/256.0;
+      prolongation[5](52,29) = -1.0/256.0;
+      prolongation[5](52,31) = -1.0/256.0;
+      prolongation[5](52,42) = 45.0/256.0;
+      prolongation[5](52,43) = 45.0/256.0;
+      prolongation[5](52,45) = -15.0/256.0;
+      prolongation[5](52,47) = 5.0/256.0;
+      prolongation[5](52,50) = 9.0/256.0;
+      prolongation[5](52,51) = 9.0/256.0;
+      prolongation[5](52,53) = -15.0/256.0;
+      prolongation[5](52,55) = 5.0/256.0;
+      prolongation[5](52,58) = 135.0/256.0;
+      prolongation[5](52,59) = 135.0/256.0;
+      prolongation[5](52,62) = -45.0/256.0;
+      prolongation[5](52,63) = -45.0/256.0;
+      prolongation[5](53,0) = -5.0/4096.0;
+      prolongation[5](53,1) = -5.0/4096.0;
+      prolongation[5](53,2) = -1.0/4096.0;
+      prolongation[5](53,3) = -1.0/4096.0;
+      prolongation[5](53,4) = -25.0/4096.0;
+      prolongation[5](53,5) = -25.0/4096.0;
+      prolongation[5](53,6) = -5.0/4096.0;
+      prolongation[5](53,7) = -5.0/4096.0;
+      prolongation[5](53,8) = 45.0/4096.0;
+      prolongation[5](53,9) = 45.0/4096.0;
+      prolongation[5](53,10) = -15.0/4096.0;
+      prolongation[5](53,11) = 5.0/4096.0;
+      prolongation[5](53,12) = 9.0/4096.0;
+      prolongation[5](53,13) = 9.0/4096.0;
+      prolongation[5](53,14) = -15.0/4096.0;
+      prolongation[5](53,15) = 5.0/4096.0;
+      prolongation[5](53,16) = 225.0/4096.0;
+      prolongation[5](53,17) = 225.0/4096.0;
+      prolongation[5](53,18) = -75.0/4096.0;
+      prolongation[5](53,19) = 25.0/4096.0;
+      prolongation[5](53,20) = 45.0/4096.0;
+      prolongation[5](53,21) = 45.0/4096.0;
+      prolongation[5](53,22) = -75.0/4096.0;
+      prolongation[5](53,23) = 25.0/4096.0;
+      prolongation[5](53,24) = 25.0/4096.0;
+      prolongation[5](53,25) = -75.0/4096.0;
+      prolongation[5](53,26) = 25.0/4096.0;
+      prolongation[5](53,27) = -75.0/4096.0;
+      prolongation[5](53,28) = 5.0/4096.0;
+      prolongation[5](53,29) = -15.0/4096.0;
+      prolongation[5](53,30) = 5.0/4096.0;
+      prolongation[5](53,31) = -15.0/4096.0;
+      prolongation[5](53,32) = 135.0/4096.0;
+      prolongation[5](53,33) = 135.0/4096.0;
+      prolongation[5](53,34) = -45.0/4096.0;
+      prolongation[5](53,35) = -45.0/4096.0;
+      prolongation[5](53,36) = 675.0/4096.0;
+      prolongation[5](53,37) = 675.0/4096.0;
+      prolongation[5](53,38) = -225.0/4096.0;
+      prolongation[5](53,39) = -225.0/4096.0;
+      prolongation[5](53,40) = -225.0/4096.0;
+      prolongation[5](53,41) = -225.0/4096.0;
+      prolongation[5](53,42) = 675.0/4096.0;
+      prolongation[5](53,43) = 675.0/4096.0;
+      prolongation[5](53,44) = 75.0/4096.0;
+      prolongation[5](53,45) = -225.0/4096.0;
+      prolongation[5](53,46) = -25.0/4096.0;
+      prolongation[5](53,47) = 75.0/4096.0;
+      prolongation[5](53,48) = -45.0/4096.0;
+      prolongation[5](53,49) = -45.0/4096.0;
+      prolongation[5](53,50) = 135.0/4096.0;
+      prolongation[5](53,51) = 135.0/4096.0;
+      prolongation[5](53,52) = 75.0/4096.0;
+      prolongation[5](53,53) = -225.0/4096.0;
+      prolongation[5](53,54) = -25.0/4096.0;
+      prolongation[5](53,55) = 75.0/4096.0;
+      prolongation[5](53,56) = -675.0/4096.0;
+      prolongation[5](53,57) = -675.0/4096.0;
+      prolongation[5](53,58) = 2025.0/4096.0;
+      prolongation[5](53,59) = 2025.0/4096.0;
+      prolongation[5](53,60) = 225.0/4096.0;
+      prolongation[5](53,61) = 225.0/4096.0;
+      prolongation[5](53,62) = -675.0/4096.0;
+      prolongation[5](53,63) = -675.0/4096.0;
+      prolongation[5](54,45) = -1.0/16.0;
+      prolongation[5](54,53) = -1.0/16.0;
+      prolongation[5](54,58) = 9.0/16.0;
+      prolongation[5](54,59) = 9.0/16.0;
+      prolongation[5](55,10) = -1.0/256.0;
+      prolongation[5](55,14) = -1.0/256.0;
+      prolongation[5](55,18) = -5.0/256.0;
+      prolongation[5](55,22) = -5.0/256.0;
+      prolongation[5](55,32) = 9.0/256.0;
+      prolongation[5](55,33) = 9.0/256.0;
+      prolongation[5](55,36) = 45.0/256.0;
+      prolongation[5](55,37) = 45.0/256.0;
+      prolongation[5](55,44) = 5.0/256.0;
+      prolongation[5](55,45) = -15.0/256.0;
+      prolongation[5](55,52) = 5.0/256.0;
+      prolongation[5](55,53) = -15.0/256.0;
+      prolongation[5](55,56) = -45.0/256.0;
+      prolongation[5](55,57) = -45.0/256.0;
+      prolongation[5](55,58) = 135.0/256.0;
+      prolongation[5](55,59) = 135.0/256.0;
+      prolongation[5](56,43) = 5.0/16.0;
+      prolongation[5](56,51) = 1.0/16.0;
+      prolongation[5](56,59) = 15.0/16.0;
+      prolongation[5](56,63) = -5.0/16.0;
+      prolongation[5](57,25) = 5.0/256.0;
+      prolongation[5](57,27) = 25.0/256.0;
+      prolongation[5](57,29) = 5.0/256.0;
+      prolongation[5](57,31) = 1.0/256.0;
+      prolongation[5](57,42) = -25.0/256.0;
+      prolongation[5](57,43) = 75.0/256.0;
+      prolongation[5](57,45) = 75.0/256.0;
+      prolongation[5](57,47) = -25.0/256.0;
+      prolongation[5](57,50) = -5.0/256.0;
+      prolongation[5](57,51) = 15.0/256.0;
+      prolongation[5](57,53) = 15.0/256.0;
+      prolongation[5](57,55) = -5.0/256.0;
+      prolongation[5](57,58) = -75.0/256.0;
+      prolongation[5](57,59) = 225.0/256.0;
+      prolongation[5](57,62) = 25.0/256.0;
+      prolongation[5](57,63) = -75.0/256.0;
+      prolongation[5](58,9) = 5.0/256.0;
+      prolongation[5](58,13) = 1.0/256.0;
+      prolongation[5](58,17) = 25.0/256.0;
+      prolongation[5](58,21) = 5.0/256.0;
+      prolongation[5](58,33) = 15.0/256.0;
+      prolongation[5](58,35) = -5.0/256.0;
+      prolongation[5](58,37) = 75.0/256.0;
+      prolongation[5](58,39) = -25.0/256.0;
+      prolongation[5](58,41) = -25.0/256.0;
+      prolongation[5](58,43) = 75.0/256.0;
+      prolongation[5](58,49) = -5.0/256.0;
+      prolongation[5](58,51) = 15.0/256.0;
+      prolongation[5](58,57) = -75.0/256.0;
+      prolongation[5](58,59) = 225.0/256.0;
+      prolongation[5](58,61) = 25.0/256.0;
+      prolongation[5](58,63) = -75.0/256.0;
+      prolongation[5](59,0) = 5.0/4096.0;
+      prolongation[5](59,1) = 25.0/4096.0;
+      prolongation[5](59,2) = 5.0/4096.0;
+      prolongation[5](59,3) = 1.0/4096.0;
+      prolongation[5](59,4) = 25.0/4096.0;
+      prolongation[5](59,5) = 125.0/4096.0;
+      prolongation[5](59,6) = 25.0/4096.0;
+      prolongation[5](59,7) = 5.0/4096.0;
+      prolongation[5](59,8) = -25.0/4096.0;
+      prolongation[5](59,9) = 75.0/4096.0;
+      prolongation[5](59,10) = 75.0/4096.0;
+      prolongation[5](59,11) = -25.0/4096.0;
+      prolongation[5](59,12) = -5.0/4096.0;
+      prolongation[5](59,13) = 15.0/4096.0;
+      prolongation[5](59,14) = 15.0/4096.0;
+      prolongation[5](59,15) = -5.0/4096.0;
+      prolongation[5](59,16) = -125.0/4096.0;
+      prolongation[5](59,17) = 375.0/4096.0;
+      prolongation[5](59,18) = 375.0/4096.0;
+      prolongation[5](59,19) = -125.0/4096.0;
+      prolongation[5](59,20) = -25.0/4096.0;
+      prolongation[5](59,21) = 75.0/4096.0;
+      prolongation[5](59,22) = 75.0/4096.0;
+      prolongation[5](59,23) = -25.0/4096.0;
+      prolongation[5](59,24) = -25.0/4096.0;
+      prolongation[5](59,25) = 75.0/4096.0;
+      prolongation[5](59,26) = -125.0/4096.0;
+      prolongation[5](59,27) = 375.0/4096.0;
+      prolongation[5](59,28) = -25.0/4096.0;
+      prolongation[5](59,29) = 75.0/4096.0;
+      prolongation[5](59,30) = -5.0/4096.0;
+      prolongation[5](59,31) = 15.0/4096.0;
+      prolongation[5](59,32) = -75.0/4096.0;
+      prolongation[5](59,33) = 225.0/4096.0;
+      prolongation[5](59,34) = 25.0/4096.0;
+      prolongation[5](59,35) = -75.0/4096.0;
+      prolongation[5](59,36) = -375.0/4096.0;
+      prolongation[5](59,37) = 1125.0/4096.0;
+      prolongation[5](59,38) = 125.0/4096.0;
+      prolongation[5](59,39) = -375.0/4096.0;
+      prolongation[5](59,40) = 125.0/4096.0;
+      prolongation[5](59,41) = -375.0/4096.0;
+      prolongation[5](59,42) = -375.0/4096.0;
+      prolongation[5](59,43) = 1125.0/4096.0;
+      prolongation[5](59,44) = -375.0/4096.0;
+      prolongation[5](59,45) = 1125.0/4096.0;
+      prolongation[5](59,46) = 125.0/4096.0;
+      prolongation[5](59,47) = -375.0/4096.0;
+      prolongation[5](59,48) = 25.0/4096.0;
+      prolongation[5](59,49) = -75.0/4096.0;
+      prolongation[5](59,50) = -75.0/4096.0;
+      prolongation[5](59,51) = 225.0/4096.0;
+      prolongation[5](59,52) = -75.0/4096.0;
+      prolongation[5](59,53) = 225.0/4096.0;
+      prolongation[5](59,54) = 25.0/4096.0;
+      prolongation[5](59,55) = -75.0/4096.0;
+      prolongation[5](59,56) = 375.0/4096.0;
+      prolongation[5](59,57) = -1125.0/4096.0;
+      prolongation[5](59,58) = -1125.0/4096.0;
+      prolongation[5](59,59) = 3375.0/4096.0;
+      prolongation[5](59,60) = -125.0/4096.0;
+      prolongation[5](59,61) = 375.0/4096.0;
+      prolongation[5](59,62) = 375.0/4096.0;
+      prolongation[5](59,63) = -1125.0/4096.0;
+      prolongation[5](60,59) = 1.0;
+      prolongation[5](61,45) = 5.0/16.0;
+      prolongation[5](61,53) = 1.0/16.0;
+      prolongation[5](61,58) = -5.0/16.0;
+      prolongation[5](61,59) = 15.0/16.0;
+      prolongation[5](62,33) = 1.0/16.0;
+      prolongation[5](62,37) = 5.0/16.0;
+      prolongation[5](62,57) = -5.0/16.0;
+      prolongation[5](62,59) = 15.0/16.0;
+      prolongation[5](63,10) = 5.0/256.0;
+      prolongation[5](63,14) = 1.0/256.0;
+      prolongation[5](63,18) = 25.0/256.0;
+      prolongation[5](63,22) = 5.0/256.0;
+      prolongation[5](63,32) = -5.0/256.0;
+      prolongation[5](63,33) = 15.0/256.0;
+      prolongation[5](63,36) = -25.0/256.0;
+      prolongation[5](63,37) = 75.0/256.0;
+      prolongation[5](63,44) = -25.0/256.0;
+      prolongation[5](63,45) = 75.0/256.0;
+      prolongation[5](63,52) = -5.0/256.0;
+      prolongation[5](63,53) = 15.0/256.0;
+      prolongation[5](63,56) = 25.0/256.0;
+      prolongation[5](63,57) = -75.0/256.0;
+      prolongation[5](63,58) = -75.0/256.0;
+      prolongation[5](63,59) = 225.0/256.0;
+      prolongation[6](0,0) = -1.0/4096.0;
+      prolongation[6](0,1) = -1.0/4096.0;
+      prolongation[6](0,2) = -1.0/4096.0;
+      prolongation[6](0,3) = -1.0/4096.0;
+      prolongation[6](0,4) = -1.0/4096.0;
+      prolongation[6](0,5) = -1.0/4096.0;
+      prolongation[6](0,6) = -1.0/4096.0;
+      prolongation[6](0,7) = -1.0/4096.0;
+      prolongation[6](0,8) = 9.0/4096.0;
+      prolongation[6](0,9) = 9.0/4096.0;
+      prolongation[6](0,10) = 9.0/4096.0;
+      prolongation[6](0,11) = 9.0/4096.0;
+      prolongation[6](0,12) = 9.0/4096.0;
+      prolongation[6](0,13) = 9.0/4096.0;
+      prolongation[6](0,14) = 9.0/4096.0;
+      prolongation[6](0,15) = 9.0/4096.0;
+      prolongation[6](0,16) = 9.0/4096.0;
+      prolongation[6](0,17) = 9.0/4096.0;
+      prolongation[6](0,18) = 9.0/4096.0;
+      prolongation[6](0,19) = 9.0/4096.0;
+      prolongation[6](0,20) = 9.0/4096.0;
+      prolongation[6](0,21) = 9.0/4096.0;
+      prolongation[6](0,22) = 9.0/4096.0;
+      prolongation[6](0,23) = 9.0/4096.0;
+      prolongation[6](0,24) = 9.0/4096.0;
+      prolongation[6](0,25) = 9.0/4096.0;
+      prolongation[6](0,26) = 9.0/4096.0;
+      prolongation[6](0,27) = 9.0/4096.0;
+      prolongation[6](0,28) = 9.0/4096.0;
+      prolongation[6](0,29) = 9.0/4096.0;
+      prolongation[6](0,30) = 9.0/4096.0;
+      prolongation[6](0,31) = 9.0/4096.0;
+      prolongation[6](0,32) = -81.0/4096.0;
+      prolongation[6](0,33) = -81.0/4096.0;
+      prolongation[6](0,34) = -81.0/4096.0;
+      prolongation[6](0,35) = -81.0/4096.0;
+      prolongation[6](0,36) = -81.0/4096.0;
+      prolongation[6](0,37) = -81.0/4096.0;
+      prolongation[6](0,38) = -81.0/4096.0;
+      prolongation[6](0,39) = -81.0/4096.0;
+      prolongation[6](0,40) = -81.0/4096.0;
+      prolongation[6](0,41) = -81.0/4096.0;
+      prolongation[6](0,42) = -81.0/4096.0;
+      prolongation[6](0,43) = -81.0/4096.0;
+      prolongation[6](0,44) = -81.0/4096.0;
+      prolongation[6](0,45) = -81.0/4096.0;
+      prolongation[6](0,46) = -81.0/4096.0;
+      prolongation[6](0,47) = -81.0/4096.0;
+      prolongation[6](0,48) = -81.0/4096.0;
+      prolongation[6](0,49) = -81.0/4096.0;
+      prolongation[6](0,50) = -81.0/4096.0;
+      prolongation[6](0,51) = -81.0/4096.0;
+      prolongation[6](0,52) = -81.0/4096.0;
+      prolongation[6](0,53) = -81.0/4096.0;
+      prolongation[6](0,54) = -81.0/4096.0;
+      prolongation[6](0,55) = -81.0/4096.0;
+      prolongation[6](0,56) = 729.0/4096.0;
+      prolongation[6](0,57) = 729.0/4096.0;
+      prolongation[6](0,58) = 729.0/4096.0;
+      prolongation[6](0,59) = 729.0/4096.0;
+      prolongation[6](0,60) = 729.0/4096.0;
+      prolongation[6](0,61) = 729.0/4096.0;
+      prolongation[6](0,62) = 729.0/4096.0;
+      prolongation[6](0,63) = 729.0/4096.0;
+      prolongation[6](1,1) = 1.0/256.0;
+      prolongation[6](1,2) = 1.0/256.0;
+      prolongation[6](1,5) = 1.0/256.0;
+      prolongation[6](1,6) = 1.0/256.0;
+      prolongation[6](1,10) = -9.0/256.0;
+      prolongation[6](1,11) = -9.0/256.0;
+      prolongation[6](1,18) = -9.0/256.0;
+      prolongation[6](1,19) = -9.0/256.0;
+      prolongation[6](1,26) = -9.0/256.0;
+      prolongation[6](1,27) = -9.0/256.0;
+      prolongation[6](1,28) = -9.0/256.0;
+      prolongation[6](1,29) = -9.0/256.0;
+      prolongation[6](1,44) = 81.0/256.0;
+      prolongation[6](1,45) = 81.0/256.0;
+      prolongation[6](1,46) = 81.0/256.0;
+      prolongation[6](1,47) = 81.0/256.0;
+      prolongation[6](2,2) = -1.0/16.0;
+      prolongation[6](2,6) = -1.0/16.0;
+      prolongation[6](2,28) = 9.0/16.0;
+      prolongation[6](2,29) = 9.0/16.0;
+      prolongation[6](3,2) = 1.0/256.0;
+      prolongation[6](3,3) = 1.0/256.0;
+      prolongation[6](3,6) = 1.0/256.0;
+      prolongation[6](3,7) = 1.0/256.0;
+      prolongation[6](3,12) = -9.0/256.0;
+      prolongation[6](3,13) = -9.0/256.0;
+      prolongation[6](3,20) = -9.0/256.0;
+      prolongation[6](3,21) = -9.0/256.0;
+      prolongation[6](3,28) = -9.0/256.0;
+      prolongation[6](3,29) = -9.0/256.0;
+      prolongation[6](3,30) = -9.0/256.0;
+      prolongation[6](3,31) = -9.0/256.0;
+      prolongation[6](3,48) = 81.0/256.0;
+      prolongation[6](3,49) = 81.0/256.0;
+      prolongation[6](3,50) = 81.0/256.0;
+      prolongation[6](3,51) = 81.0/256.0;
+      prolongation[6](4,4) = 1.0/256.0;
+      prolongation[6](4,5) = 1.0/256.0;
+      prolongation[6](4,6) = 1.0/256.0;
+      prolongation[6](4,7) = 1.0/256.0;
+      prolongation[6](4,16) = -9.0/256.0;
+      prolongation[6](4,17) = -9.0/256.0;
+      prolongation[6](4,18) = -9.0/256.0;
+      prolongation[6](4,19) = -9.0/256.0;
+      prolongation[6](4,20) = -9.0/256.0;
+      prolongation[6](4,21) = -9.0/256.0;
+      prolongation[6](4,22) = -9.0/256.0;
+      prolongation[6](4,23) = -9.0/256.0;
+      prolongation[6](4,36) = 81.0/256.0;
+      prolongation[6](4,37) = 81.0/256.0;
+      prolongation[6](4,38) = 81.0/256.0;
+      prolongation[6](4,39) = 81.0/256.0;
+      prolongation[6](5,5) = -1.0/16.0;
+      prolongation[6](5,6) = -1.0/16.0;
+      prolongation[6](5,18) = 9.0/16.0;
+      prolongation[6](5,19) = 9.0/16.0;
+      prolongation[6](6,6) = 1.0;
+      prolongation[6](7,6) = -1.0/16.0;
+      prolongation[6](7,7) = -1.0/16.0;
+      prolongation[6](7,20) = 9.0/16.0;
+      prolongation[6](7,21) = 9.0/16.0;
+      prolongation[6](8,9) = 1.0/256.0;
+      prolongation[6](8,13) = 1.0/256.0;
+      prolongation[6](8,17) = 1.0/256.0;
+      prolongation[6](8,21) = 1.0/256.0;
+      prolongation[6](8,33) = -9.0/256.0;
+      prolongation[6](8,35) = -9.0/256.0;
+      prolongation[6](8,37) = -9.0/256.0;
+      prolongation[6](8,39) = -9.0/256.0;
+      prolongation[6](8,41) = -9.0/256.0;
+      prolongation[6](8,43) = -9.0/256.0;
+      prolongation[6](8,49) = -9.0/256.0;
+      prolongation[6](8,51) = -9.0/256.0;
+      prolongation[6](8,57) = 81.0/256.0;
+      prolongation[6](8,59) = 81.0/256.0;
+      prolongation[6](8,61) = 81.0/256.0;
+      prolongation[6](8,63) = 81.0/256.0;
+      prolongation[6](9,0) = 1.0/4096.0;
+      prolongation[6](9,1) = 5.0/4096.0;
+      prolongation[6](9,2) = 5.0/4096.0;
+      prolongation[6](9,3) = 1.0/4096.0;
+      prolongation[6](9,4) = 1.0/4096.0;
+      prolongation[6](9,5) = 5.0/4096.0;
+      prolongation[6](9,6) = 5.0/4096.0;
+      prolongation[6](9,7) = 1.0/4096.0;
+      prolongation[6](9,8) = -5.0/4096.0;
+      prolongation[6](9,9) = 15.0/4096.0;
+      prolongation[6](9,10) = -45.0/4096.0;
+      prolongation[6](9,11) = -45.0/4096.0;
+      prolongation[6](9,12) = -5.0/4096.0;
+      prolongation[6](9,13) = 15.0/4096.0;
+      prolongation[6](9,14) = -9.0/4096.0;
+      prolongation[6](9,15) = -9.0/4096.0;
+      prolongation[6](9,16) = -5.0/4096.0;
+      prolongation[6](9,17) = 15.0/4096.0;
+      prolongation[6](9,18) = -45.0/4096.0;
+      prolongation[6](9,19) = -45.0/4096.0;
+      prolongation[6](9,20) = -5.0/4096.0;
+      prolongation[6](9,21) = 15.0/4096.0;
+      prolongation[6](9,22) = -9.0/4096.0;
+      prolongation[6](9,23) = -9.0/4096.0;
+      prolongation[6](9,24) = -9.0/4096.0;
+      prolongation[6](9,25) = -9.0/4096.0;
+      prolongation[6](9,26) = -45.0/4096.0;
+      prolongation[6](9,27) = -45.0/4096.0;
+      prolongation[6](9,28) = -45.0/4096.0;
+      prolongation[6](9,29) = -45.0/4096.0;
+      prolongation[6](9,30) = -9.0/4096.0;
+      prolongation[6](9,31) = -9.0/4096.0;
+      prolongation[6](9,32) = 45.0/4096.0;
+      prolongation[6](9,33) = -135.0/4096.0;
+      prolongation[6](9,34) = 45.0/4096.0;
+      prolongation[6](9,35) = -135.0/4096.0;
+      prolongation[6](9,36) = 45.0/4096.0;
+      prolongation[6](9,37) = -135.0/4096.0;
+      prolongation[6](9,38) = 45.0/4096.0;
+      prolongation[6](9,39) = -135.0/4096.0;
+      prolongation[6](9,40) = 45.0/4096.0;
+      prolongation[6](9,41) = -135.0/4096.0;
+      prolongation[6](9,42) = 45.0/4096.0;
+      prolongation[6](9,43) = -135.0/4096.0;
+      prolongation[6](9,44) = 405.0/4096.0;
+      prolongation[6](9,45) = 405.0/4096.0;
+      prolongation[6](9,46) = 405.0/4096.0;
+      prolongation[6](9,47) = 405.0/4096.0;
+      prolongation[6](9,48) = 45.0/4096.0;
+      prolongation[6](9,49) = -135.0/4096.0;
+      prolongation[6](9,50) = 45.0/4096.0;
+      prolongation[6](9,51) = -135.0/4096.0;
+      prolongation[6](9,52) = 81.0/4096.0;
+      prolongation[6](9,53) = 81.0/4096.0;
+      prolongation[6](9,54) = 81.0/4096.0;
+      prolongation[6](9,55) = 81.0/4096.0;
+      prolongation[6](9,56) = -405.0/4096.0;
+      prolongation[6](9,57) = 1215.0/4096.0;
+      prolongation[6](9,58) = -405.0/4096.0;
+      prolongation[6](9,59) = 1215.0/4096.0;
+      prolongation[6](9,60) = -405.0/4096.0;
+      prolongation[6](9,61) = 1215.0/4096.0;
+      prolongation[6](9,62) = -405.0/4096.0;
+      prolongation[6](9,63) = 1215.0/4096.0;
+      prolongation[6](10,11) = -1.0/16.0;
+      prolongation[6](10,19) = -1.0/16.0;
+      prolongation[6](10,46) = 9.0/16.0;
+      prolongation[6](10,47) = 9.0/16.0;
+      prolongation[6](11,1) = -1.0/256.0;
+      prolongation[6](11,2) = -5.0/256.0;
+      prolongation[6](11,5) = -1.0/256.0;
+      prolongation[6](11,6) = -5.0/256.0;
+      prolongation[6](11,10) = 5.0/256.0;
+      prolongation[6](11,11) = -15.0/256.0;
+      prolongation[6](11,18) = 5.0/256.0;
+      prolongation[6](11,19) = -15.0/256.0;
+      prolongation[6](11,26) = 9.0/256.0;
+      prolongation[6](11,27) = 9.0/256.0;
+      prolongation[6](11,28) = 45.0/256.0;
+      prolongation[6](11,29) = 45.0/256.0;
+      prolongation[6](11,44) = -45.0/256.0;
+      prolongation[6](11,45) = -45.0/256.0;
+      prolongation[6](11,46) = 135.0/256.0;
+      prolongation[6](11,47) = 135.0/256.0;
+      prolongation[6](12,13) = -1.0/16.0;
+      prolongation[6](12,21) = -1.0/16.0;
+      prolongation[6](12,49) = 9.0/16.0;
+      prolongation[6](12,51) = 9.0/16.0;
+      prolongation[6](13,2) = -5.0/256.0;
+      prolongation[6](13,3) = -1.0/256.0;
+      prolongation[6](13,6) = -5.0/256.0;
+      prolongation[6](13,7) = -1.0/256.0;
+      prolongation[6](13,12) = 5.0/256.0;
+      prolongation[6](13,13) = -15.0/256.0;
+      prolongation[6](13,20) = 5.0/256.0;
+      prolongation[6](13,21) = -15.0/256.0;
+      prolongation[6](13,28) = 45.0/256.0;
+      prolongation[6](13,29) = 45.0/256.0;
+      prolongation[6](13,30) = 9.0/256.0;
+      prolongation[6](13,31) = 9.0/256.0;
+      prolongation[6](13,48) = -45.0/256.0;
+      prolongation[6](13,49) = 135.0/256.0;
+      prolongation[6](13,50) = -45.0/256.0;
+      prolongation[6](13,51) = 135.0/256.0;
+      prolongation[6](14,11) = 1.0/256.0;
+      prolongation[6](14,15) = 1.0/256.0;
+      prolongation[6](14,19) = 1.0/256.0;
+      prolongation[6](14,23) = 1.0/256.0;
+      prolongation[6](14,34) = -9.0/256.0;
+      prolongation[6](14,35) = -9.0/256.0;
+      prolongation[6](14,38) = -9.0/256.0;
+      prolongation[6](14,39) = -9.0/256.0;
+      prolongation[6](14,46) = -9.0/256.0;
+      prolongation[6](14,47) = -9.0/256.0;
+      prolongation[6](14,54) = -9.0/256.0;
+      prolongation[6](14,55) = -9.0/256.0;
+      prolongation[6](14,60) = 81.0/256.0;
+      prolongation[6](14,61) = 81.0/256.0;
+      prolongation[6](14,62) = 81.0/256.0;
+      prolongation[6](14,63) = 81.0/256.0;
+      prolongation[6](15,0) = 1.0/4096.0;
+      prolongation[6](15,1) = 1.0/4096.0;
+      prolongation[6](15,2) = 5.0/4096.0;
+      prolongation[6](15,3) = 5.0/4096.0;
+      prolongation[6](15,4) = 1.0/4096.0;
+      prolongation[6](15,5) = 1.0/4096.0;
+      prolongation[6](15,6) = 5.0/4096.0;
+      prolongation[6](15,7) = 5.0/4096.0;
+      prolongation[6](15,8) = -9.0/4096.0;
+      prolongation[6](15,9) = -9.0/4096.0;
+      prolongation[6](15,10) = -5.0/4096.0;
+      prolongation[6](15,11) = 15.0/4096.0;
+      prolongation[6](15,12) = -45.0/4096.0;
+      prolongation[6](15,13) = -45.0/4096.0;
+      prolongation[6](15,14) = -5.0/4096.0;
+      prolongation[6](15,15) = 15.0/4096.0;
+      prolongation[6](15,16) = -9.0/4096.0;
+      prolongation[6](15,17) = -9.0/4096.0;
+      prolongation[6](15,18) = -5.0/4096.0;
+      prolongation[6](15,19) = 15.0/4096.0;
+      prolongation[6](15,20) = -45.0/4096.0;
+      prolongation[6](15,21) = -45.0/4096.0;
+      prolongation[6](15,22) = -5.0/4096.0;
+      prolongation[6](15,23) = 15.0/4096.0;
+      prolongation[6](15,24) = -9.0/4096.0;
+      prolongation[6](15,25) = -9.0/4096.0;
+      prolongation[6](15,26) = -9.0/4096.0;
+      prolongation[6](15,27) = -9.0/4096.0;
+      prolongation[6](15,28) = -45.0/4096.0;
+      prolongation[6](15,29) = -45.0/4096.0;
+      prolongation[6](15,30) = -45.0/4096.0;
+      prolongation[6](15,31) = -45.0/4096.0;
+      prolongation[6](15,32) = 45.0/4096.0;
+      prolongation[6](15,33) = 45.0/4096.0;
+      prolongation[6](15,34) = -135.0/4096.0;
+      prolongation[6](15,35) = -135.0/4096.0;
+      prolongation[6](15,36) = 45.0/4096.0;
+      prolongation[6](15,37) = 45.0/4096.0;
+      prolongation[6](15,38) = -135.0/4096.0;
+      prolongation[6](15,39) = -135.0/4096.0;
+      prolongation[6](15,40) = 81.0/4096.0;
+      prolongation[6](15,41) = 81.0/4096.0;
+      prolongation[6](15,42) = 81.0/4096.0;
+      prolongation[6](15,43) = 81.0/4096.0;
+      prolongation[6](15,44) = 45.0/4096.0;
+      prolongation[6](15,45) = 45.0/4096.0;
+      prolongation[6](15,46) = -135.0/4096.0;
+      prolongation[6](15,47) = -135.0/4096.0;
+      prolongation[6](15,48) = 405.0/4096.0;
+      prolongation[6](15,49) = 405.0/4096.0;
+      prolongation[6](15,50) = 405.0/4096.0;
+      prolongation[6](15,51) = 405.0/4096.0;
+      prolongation[6](15,52) = 45.0/4096.0;
+      prolongation[6](15,53) = 45.0/4096.0;
+      prolongation[6](15,54) = -135.0/4096.0;
+      prolongation[6](15,55) = -135.0/4096.0;
+      prolongation[6](15,56) = -405.0/4096.0;
+      prolongation[6](15,57) = -405.0/4096.0;
+      prolongation[6](15,58) = -405.0/4096.0;
+      prolongation[6](15,59) = -405.0/4096.0;
+      prolongation[6](15,60) = 1215.0/4096.0;
+      prolongation[6](15,61) = 1215.0/4096.0;
+      prolongation[6](15,62) = 1215.0/4096.0;
+      prolongation[6](15,63) = 1215.0/4096.0;
+      prolongation[6](16,17) = -1.0/16.0;
+      prolongation[6](16,21) = -1.0/16.0;
+      prolongation[6](16,37) = 9.0/16.0;
+      prolongation[6](16,39) = 9.0/16.0;
+      prolongation[6](17,4) = -1.0/256.0;
+      prolongation[6](17,5) = -5.0/256.0;
+      prolongation[6](17,6) = -5.0/256.0;
+      prolongation[6](17,7) = -1.0/256.0;
+      prolongation[6](17,16) = 5.0/256.0;
+      prolongation[6](17,17) = -15.0/256.0;
+      prolongation[6](17,18) = 45.0/256.0;
+      prolongation[6](17,19) = 45.0/256.0;
+      prolongation[6](17,20) = 5.0/256.0;
+      prolongation[6](17,21) = -15.0/256.0;
+      prolongation[6](17,22) = 9.0/256.0;
+      prolongation[6](17,23) = 9.0/256.0;
+      prolongation[6](17,36) = -45.0/256.0;
+      prolongation[6](17,37) = 135.0/256.0;
+      prolongation[6](17,38) = -45.0/256.0;
+      prolongation[6](17,39) = 135.0/256.0;
+      prolongation[6](18,19) = 1.0;
+      prolongation[6](19,5) = 1.0/16.0;
+      prolongation[6](19,6) = 5.0/16.0;
+      prolongation[6](19,18) = -5.0/16.0;
+      prolongation[6](19,19) = 15.0/16.0;
+      prolongation[6](20,21) = 1.0;
+      prolongation[6](21,6) = 5.0/16.0;
+      prolongation[6](21,7) = 1.0/16.0;
+      prolongation[6](21,20) = -5.0/16.0;
+      prolongation[6](21,21) = 15.0/16.0;
+      prolongation[6](22,19) = -1.0/16.0;
+      prolongation[6](22,23) = -1.0/16.0;
+      prolongation[6](22,38) = 9.0/16.0;
+      prolongation[6](22,39) = 9.0/16.0;
+      prolongation[6](23,4) = -1.0/256.0;
+      prolongation[6](23,5) = -1.0/256.0;
+      prolongation[6](23,6) = -5.0/256.0;
+      prolongation[6](23,7) = -5.0/256.0;
+      prolongation[6](23,16) = 9.0/256.0;
+      prolongation[6](23,17) = 9.0/256.0;
+      prolongation[6](23,18) = 5.0/256.0;
+      prolongation[6](23,19) = -15.0/256.0;
+      prolongation[6](23,20) = 45.0/256.0;
+      prolongation[6](23,21) = 45.0/256.0;
+      prolongation[6](23,22) = 5.0/256.0;
+      prolongation[6](23,23) = -15.0/256.0;
+      prolongation[6](23,36) = -45.0/256.0;
+      prolongation[6](23,37) = -45.0/256.0;
+      prolongation[6](23,38) = 135.0/256.0;
+      prolongation[6](23,39) = 135.0/256.0;
+      prolongation[6](24,25) = 1.0/256.0;
+      prolongation[6](24,27) = 1.0/256.0;
+      prolongation[6](24,29) = 1.0/256.0;
+      prolongation[6](24,31) = 1.0/256.0;
+      prolongation[6](24,42) = -9.0/256.0;
+      prolongation[6](24,43) = -9.0/256.0;
+      prolongation[6](24,45) = -9.0/256.0;
+      prolongation[6](24,47) = -9.0/256.0;
+      prolongation[6](24,50) = -9.0/256.0;
+      prolongation[6](24,51) = -9.0/256.0;
+      prolongation[6](24,53) = -9.0/256.0;
+      prolongation[6](24,55) = -9.0/256.0;
+      prolongation[6](24,58) = 81.0/256.0;
+      prolongation[6](24,59) = 81.0/256.0;
+      prolongation[6](24,62) = 81.0/256.0;
+      prolongation[6](24,63) = 81.0/256.0;
+      prolongation[6](25,0) = 1.0/4096.0;
+      prolongation[6](25,1) = 1.0/4096.0;
+      prolongation[6](25,2) = 1.0/4096.0;
+      prolongation[6](25,3) = 1.0/4096.0;
+      prolongation[6](25,4) = 5.0/4096.0;
+      prolongation[6](25,5) = 5.0/4096.0;
+      prolongation[6](25,6) = 5.0/4096.0;
+      prolongation[6](25,7) = 5.0/4096.0;
+      prolongation[6](25,8) = -9.0/4096.0;
+      prolongation[6](25,9) = -9.0/4096.0;
+      prolongation[6](25,10) = -9.0/4096.0;
+      prolongation[6](25,11) = -9.0/4096.0;
+      prolongation[6](25,12) = -9.0/4096.0;
+      prolongation[6](25,13) = -9.0/4096.0;
+      prolongation[6](25,14) = -9.0/4096.0;
+      prolongation[6](25,15) = -9.0/4096.0;
+      prolongation[6](25,16) = -45.0/4096.0;
+      prolongation[6](25,17) = -45.0/4096.0;
+      prolongation[6](25,18) = -45.0/4096.0;
+      prolongation[6](25,19) = -45.0/4096.0;
+      prolongation[6](25,20) = -45.0/4096.0;
+      prolongation[6](25,21) = -45.0/4096.0;
+      prolongation[6](25,22) = -45.0/4096.0;
+      prolongation[6](25,23) = -45.0/4096.0;
+      prolongation[6](25,24) = -5.0/4096.0;
+      prolongation[6](25,25) = 15.0/4096.0;
+      prolongation[6](25,26) = -5.0/4096.0;
+      prolongation[6](25,27) = 15.0/4096.0;
+      prolongation[6](25,28) = -5.0/4096.0;
+      prolongation[6](25,29) = 15.0/4096.0;
+      prolongation[6](25,30) = -5.0/4096.0;
+      prolongation[6](25,31) = 15.0/4096.0;
+      prolongation[6](25,32) = 81.0/4096.0;
+      prolongation[6](25,33) = 81.0/4096.0;
+      prolongation[6](25,34) = 81.0/4096.0;
+      prolongation[6](25,35) = 81.0/4096.0;
+      prolongation[6](25,36) = 405.0/4096.0;
+      prolongation[6](25,37) = 405.0/4096.0;
+      prolongation[6](25,38) = 405.0/4096.0;
+      prolongation[6](25,39) = 405.0/4096.0;
+      prolongation[6](25,40) = 45.0/4096.0;
+      prolongation[6](25,41) = 45.0/4096.0;
+      prolongation[6](25,42) = -135.0/4096.0;
+      prolongation[6](25,43) = -135.0/4096.0;
+      prolongation[6](25,44) = 45.0/4096.0;
+      prolongation[6](25,45) = -135.0/4096.0;
+      prolongation[6](25,46) = 45.0/4096.0;
+      prolongation[6](25,47) = -135.0/4096.0;
+      prolongation[6](25,48) = 45.0/4096.0;
+      prolongation[6](25,49) = 45.0/4096.0;
+      prolongation[6](25,50) = -135.0/4096.0;
+      prolongation[6](25,51) = -135.0/4096.0;
+      prolongation[6](25,52) = 45.0/4096.0;
+      prolongation[6](25,53) = -135.0/4096.0;
+      prolongation[6](25,54) = 45.0/4096.0;
+      prolongation[6](25,55) = -135.0/4096.0;
+      prolongation[6](25,56) = -405.0/4096.0;
+      prolongation[6](25,57) = -405.0/4096.0;
+      prolongation[6](25,58) = 1215.0/4096.0;
+      prolongation[6](25,59) = 1215.0/4096.0;
+      prolongation[6](25,60) = -405.0/4096.0;
+      prolongation[6](25,61) = -405.0/4096.0;
+      prolongation[6](25,62) = 1215.0/4096.0;
+      prolongation[6](25,63) = 1215.0/4096.0;
+      prolongation[6](26,27) = -1.0/16.0;
+      prolongation[6](26,29) = -1.0/16.0;
+      prolongation[6](26,45) = 9.0/16.0;
+      prolongation[6](26,47) = 9.0/16.0;
+      prolongation[6](27,1) = -1.0/256.0;
+      prolongation[6](27,2) = -1.0/256.0;
+      prolongation[6](27,5) = -5.0/256.0;
+      prolongation[6](27,6) = -5.0/256.0;
+      prolongation[6](27,10) = 9.0/256.0;
+      prolongation[6](27,11) = 9.0/256.0;
+      prolongation[6](27,18) = 45.0/256.0;
+      prolongation[6](27,19) = 45.0/256.0;
+      prolongation[6](27,26) = 5.0/256.0;
+      prolongation[6](27,27) = -15.0/256.0;
+      prolongation[6](27,28) = 5.0/256.0;
+      prolongation[6](27,29) = -15.0/256.0;
+      prolongation[6](27,44) = -45.0/256.0;
+      prolongation[6](27,45) = 135.0/256.0;
+      prolongation[6](27,46) = -45.0/256.0;
+      prolongation[6](27,47) = 135.0/256.0;
+      prolongation[6](28,29) = 1.0;
+      prolongation[6](29,2) = 1.0/16.0;
+      prolongation[6](29,6) = 5.0/16.0;
+      prolongation[6](29,28) = -5.0/16.0;
+      prolongation[6](29,29) = 15.0/16.0;
+      prolongation[6](30,29) = -1.0/16.0;
+      prolongation[6](30,31) = -1.0/16.0;
+      prolongation[6](30,50) = 9.0/16.0;
+      prolongation[6](30,51) = 9.0/16.0;
+      prolongation[6](31,2) = -1.0/256.0;
+      prolongation[6](31,3) = -1.0/256.0;
+      prolongation[6](31,6) = -5.0/256.0;
+      prolongation[6](31,7) = -5.0/256.0;
+      prolongation[6](31,12) = 9.0/256.0;
+      prolongation[6](31,13) = 9.0/256.0;
+      prolongation[6](31,20) = 45.0/256.0;
+      prolongation[6](31,21) = 45.0/256.0;
+      prolongation[6](31,28) = 5.0/256.0;
+      prolongation[6](31,29) = -15.0/256.0;
+      prolongation[6](31,30) = 5.0/256.0;
+      prolongation[6](31,31) = -15.0/256.0;
+      prolongation[6](31,48) = -45.0/256.0;
+      prolongation[6](31,49) = -45.0/256.0;
+      prolongation[6](31,50) = 135.0/256.0;
+      prolongation[6](31,51) = 135.0/256.0;
+      prolongation[6](32,35) = -1.0/16.0;
+      prolongation[6](32,39) = -1.0/16.0;
+      prolongation[6](32,61) = 9.0/16.0;
+      prolongation[6](32,63) = 9.0/16.0;
+      prolongation[6](33,11) = -5.0/256.0;
+      prolongation[6](33,15) = -1.0/256.0;
+      prolongation[6](33,19) = -5.0/256.0;
+      prolongation[6](33,23) = -1.0/256.0;
+      prolongation[6](33,34) = 5.0/256.0;
+      prolongation[6](33,35) = -15.0/256.0;
+      prolongation[6](33,38) = 5.0/256.0;
+      prolongation[6](33,39) = -15.0/256.0;
+      prolongation[6](33,46) = 45.0/256.0;
+      prolongation[6](33,47) = 45.0/256.0;
+      prolongation[6](33,54) = 9.0/256.0;
+      prolongation[6](33,55) = 9.0/256.0;
+      prolongation[6](33,60) = -45.0/256.0;
+      prolongation[6](33,61) = 135.0/256.0;
+      prolongation[6](33,62) = -45.0/256.0;
+      prolongation[6](33,63) = 135.0/256.0;
+      prolongation[6](34,9) = -1.0/256.0;
+      prolongation[6](34,13) = -5.0/256.0;
+      prolongation[6](34,17) = -1.0/256.0;
+      prolongation[6](34,21) = -5.0/256.0;
+      prolongation[6](34,33) = 5.0/256.0;
+      prolongation[6](34,35) = -15.0/256.0;
+      prolongation[6](34,37) = 5.0/256.0;
+      prolongation[6](34,39) = -15.0/256.0;
+      prolongation[6](34,41) = 9.0/256.0;
+      prolongation[6](34,43) = 9.0/256.0;
+      prolongation[6](34,49) = 45.0/256.0;
+      prolongation[6](34,51) = 45.0/256.0;
+      prolongation[6](34,57) = -45.0/256.0;
+      prolongation[6](34,59) = -45.0/256.0;
+      prolongation[6](34,61) = 135.0/256.0;
+      prolongation[6](34,63) = 135.0/256.0;
+      prolongation[6](35,0) = -1.0/4096.0;
+      prolongation[6](35,1) = -5.0/4096.0;
+      prolongation[6](35,2) = -25.0/4096.0;
+      prolongation[6](35,3) = -5.0/4096.0;
+      prolongation[6](35,4) = -1.0/4096.0;
+      prolongation[6](35,5) = -5.0/4096.0;
+      prolongation[6](35,6) = -25.0/4096.0;
+      prolongation[6](35,7) = -5.0/4096.0;
+      prolongation[6](35,8) = 5.0/4096.0;
+      prolongation[6](35,9) = -15.0/4096.0;
+      prolongation[6](35,10) = 25.0/4096.0;
+      prolongation[6](35,11) = -75.0/4096.0;
+      prolongation[6](35,12) = 25.0/4096.0;
+      prolongation[6](35,13) = -75.0/4096.0;
+      prolongation[6](35,14) = 5.0/4096.0;
+      prolongation[6](35,15) = -15.0/4096.0;
+      prolongation[6](35,16) = 5.0/4096.0;
+      prolongation[6](35,17) = -15.0/4096.0;
+      prolongation[6](35,18) = 25.0/4096.0;
+      prolongation[6](35,19) = -75.0/4096.0;
+      prolongation[6](35,20) = 25.0/4096.0;
+      prolongation[6](35,21) = -75.0/4096.0;
+      prolongation[6](35,22) = 5.0/4096.0;
+      prolongation[6](35,23) = -15.0/4096.0;
+      prolongation[6](35,24) = 9.0/4096.0;
+      prolongation[6](35,25) = 9.0/4096.0;
+      prolongation[6](35,26) = 45.0/4096.0;
+      prolongation[6](35,27) = 45.0/4096.0;
+      prolongation[6](35,28) = 225.0/4096.0;
+      prolongation[6](35,29) = 225.0/4096.0;
+      prolongation[6](35,30) = 45.0/4096.0;
+      prolongation[6](35,31) = 45.0/4096.0;
+      prolongation[6](35,32) = -25.0/4096.0;
+      prolongation[6](35,33) = 75.0/4096.0;
+      prolongation[6](35,34) = 75.0/4096.0;
+      prolongation[6](35,35) = -225.0/4096.0;
+      prolongation[6](35,36) = -25.0/4096.0;
+      prolongation[6](35,37) = 75.0/4096.0;
+      prolongation[6](35,38) = 75.0/4096.0;
+      prolongation[6](35,39) = -225.0/4096.0;
+      prolongation[6](35,40) = -45.0/4096.0;
+      prolongation[6](35,41) = 135.0/4096.0;
+      prolongation[6](35,42) = -45.0/4096.0;
+      prolongation[6](35,43) = 135.0/4096.0;
+      prolongation[6](35,44) = -225.0/4096.0;
+      prolongation[6](35,45) = -225.0/4096.0;
+      prolongation[6](35,46) = 675.0/4096.0;
+      prolongation[6](35,47) = 675.0/4096.0;
+      prolongation[6](35,48) = -225.0/4096.0;
+      prolongation[6](35,49) = 675.0/4096.0;
+      prolongation[6](35,50) = -225.0/4096.0;
+      prolongation[6](35,51) = 675.0/4096.0;
+      prolongation[6](35,52) = -45.0/4096.0;
+      prolongation[6](35,53) = -45.0/4096.0;
+      prolongation[6](35,54) = 135.0/4096.0;
+      prolongation[6](35,55) = 135.0/4096.0;
+      prolongation[6](35,56) = 225.0/4096.0;
+      prolongation[6](35,57) = -675.0/4096.0;
+      prolongation[6](35,58) = 225.0/4096.0;
+      prolongation[6](35,59) = -675.0/4096.0;
+      prolongation[6](35,60) = -675.0/4096.0;
+      prolongation[6](35,61) = 2025.0/4096.0;
+      prolongation[6](35,62) = -675.0/4096.0;
+      prolongation[6](35,63) = 2025.0/4096.0;
+      prolongation[6](36,39) = 1.0;
+      prolongation[6](37,19) = 5.0/16.0;
+      prolongation[6](37,23) = 1.0/16.0;
+      prolongation[6](37,38) = -5.0/16.0;
+      prolongation[6](37,39) = 15.0/16.0;
+      prolongation[6](38,17) = 1.0/16.0;
+      prolongation[6](38,21) = 5.0/16.0;
+      prolongation[6](38,37) = -5.0/16.0;
+      prolongation[6](38,39) = 15.0/16.0;
+      prolongation[6](39,4) = 1.0/256.0;
+      prolongation[6](39,5) = 5.0/256.0;
+      prolongation[6](39,6) = 25.0/256.0;
+      prolongation[6](39,7) = 5.0/256.0;
+      prolongation[6](39,16) = -5.0/256.0;
+      prolongation[6](39,17) = 15.0/256.0;
+      prolongation[6](39,18) = -25.0/256.0;
+      prolongation[6](39,19) = 75.0/256.0;
+      prolongation[6](39,20) = -25.0/256.0;
+      prolongation[6](39,21) = 75.0/256.0;
+      prolongation[6](39,22) = -5.0/256.0;
+      prolongation[6](39,23) = 15.0/256.0;
+      prolongation[6](39,36) = 25.0/256.0;
+      prolongation[6](39,37) = -75.0/256.0;
+      prolongation[6](39,38) = -75.0/256.0;
+      prolongation[6](39,39) = 225.0/256.0;
+      prolongation[6](40,43) = -1.0/16.0;
+      prolongation[6](40,51) = -1.0/16.0;
+      prolongation[6](40,59) = 9.0/16.0;
+      prolongation[6](40,63) = 9.0/16.0;
+      prolongation[6](41,25) = -1.0/256.0;
+      prolongation[6](41,27) = -5.0/256.0;
+      prolongation[6](41,29) = -5.0/256.0;
+      prolongation[6](41,31) = -1.0/256.0;
+      prolongation[6](41,42) = 5.0/256.0;
+      prolongation[6](41,43) = -15.0/256.0;
+      prolongation[6](41,45) = 45.0/256.0;
+      prolongation[6](41,47) = 45.0/256.0;
+      prolongation[6](41,50) = 5.0/256.0;
+      prolongation[6](41,51) = -15.0/256.0;
+      prolongation[6](41,53) = 9.0/256.0;
+      prolongation[6](41,55) = 9.0/256.0;
+      prolongation[6](41,58) = -45.0/256.0;
+      prolongation[6](41,59) = 135.0/256.0;
+      prolongation[6](41,62) = -45.0/256.0;
+      prolongation[6](41,63) = 135.0/256.0;
+      prolongation[6](42,9) = -1.0/256.0;
+      prolongation[6](42,13) = -1.0/256.0;
+      prolongation[6](42,17) = -5.0/256.0;
+      prolongation[6](42,21) = -5.0/256.0;
+      prolongation[6](42,33) = 9.0/256.0;
+      prolongation[6](42,35) = 9.0/256.0;
+      prolongation[6](42,37) = 45.0/256.0;
+      prolongation[6](42,39) = 45.0/256.0;
+      prolongation[6](42,41) = 5.0/256.0;
+      prolongation[6](42,43) = -15.0/256.0;
+      prolongation[6](42,49) = 5.0/256.0;
+      prolongation[6](42,51) = -15.0/256.0;
+      prolongation[6](42,57) = -45.0/256.0;
+      prolongation[6](42,59) = 135.0/256.0;
+      prolongation[6](42,61) = -45.0/256.0;
+      prolongation[6](42,63) = 135.0/256.0;
+      prolongation[6](43,0) = -1.0/4096.0;
+      prolongation[6](43,1) = -5.0/4096.0;
+      prolongation[6](43,2) = -5.0/4096.0;
+      prolongation[6](43,3) = -1.0/4096.0;
+      prolongation[6](43,4) = -5.0/4096.0;
+      prolongation[6](43,5) = -25.0/4096.0;
+      prolongation[6](43,6) = -25.0/4096.0;
+      prolongation[6](43,7) = -5.0/4096.0;
+      prolongation[6](43,8) = 5.0/4096.0;
+      prolongation[6](43,9) = -15.0/4096.0;
+      prolongation[6](43,10) = 45.0/4096.0;
+      prolongation[6](43,11) = 45.0/4096.0;
+      prolongation[6](43,12) = 5.0/4096.0;
+      prolongation[6](43,13) = -15.0/4096.0;
+      prolongation[6](43,14) = 9.0/4096.0;
+      prolongation[6](43,15) = 9.0/4096.0;
+      prolongation[6](43,16) = 25.0/4096.0;
+      prolongation[6](43,17) = -75.0/4096.0;
+      prolongation[6](43,18) = 225.0/4096.0;
+      prolongation[6](43,19) = 225.0/4096.0;
+      prolongation[6](43,20) = 25.0/4096.0;
+      prolongation[6](43,21) = -75.0/4096.0;
+      prolongation[6](43,22) = 45.0/4096.0;
+      prolongation[6](43,23) = 45.0/4096.0;
+      prolongation[6](43,24) = 5.0/4096.0;
+      prolongation[6](43,25) = -15.0/4096.0;
+      prolongation[6](43,26) = 25.0/4096.0;
+      prolongation[6](43,27) = -75.0/4096.0;
+      prolongation[6](43,28) = 25.0/4096.0;
+      prolongation[6](43,29) = -75.0/4096.0;
+      prolongation[6](43,30) = 5.0/4096.0;
+      prolongation[6](43,31) = -15.0/4096.0;
+      prolongation[6](43,32) = -45.0/4096.0;
+      prolongation[6](43,33) = 135.0/4096.0;
+      prolongation[6](43,34) = -45.0/4096.0;
+      prolongation[6](43,35) = 135.0/4096.0;
+      prolongation[6](43,36) = -225.0/4096.0;
+      prolongation[6](43,37) = 675.0/4096.0;
+      prolongation[6](43,38) = -225.0/4096.0;
+      prolongation[6](43,39) = 675.0/4096.0;
+      prolongation[6](43,40) = -25.0/4096.0;
+      prolongation[6](43,41) = 75.0/4096.0;
+      prolongation[6](43,42) = 75.0/4096.0;
+      prolongation[6](43,43) = -225.0/4096.0;
+      prolongation[6](43,44) = -225.0/4096.0;
+      prolongation[6](43,45) = 675.0/4096.0;
+      prolongation[6](43,46) = -225.0/4096.0;
+      prolongation[6](43,47) = 675.0/4096.0;
+      prolongation[6](43,48) = -25.0/4096.0;
+      prolongation[6](43,49) = 75.0/4096.0;
+      prolongation[6](43,50) = 75.0/4096.0;
+      prolongation[6](43,51) = -225.0/4096.0;
+      prolongation[6](43,52) = -45.0/4096.0;
+      prolongation[6](43,53) = 135.0/4096.0;
+      prolongation[6](43,54) = -45.0/4096.0;
+      prolongation[6](43,55) = 135.0/4096.0;
+      prolongation[6](43,56) = 225.0/4096.0;
+      prolongation[6](43,57) = -675.0/4096.0;
+      prolongation[6](43,58) = -675.0/4096.0;
+      prolongation[6](43,59) = 2025.0/4096.0;
+      prolongation[6](43,60) = 225.0/4096.0;
+      prolongation[6](43,61) = -675.0/4096.0;
+      prolongation[6](43,62) = -675.0/4096.0;
+      prolongation[6](43,63) = 2025.0/4096.0;
+      prolongation[6](44,47) = 1.0;
+      prolongation[6](45,11) = 1.0/16.0;
+      prolongation[6](45,19) = 5.0/16.0;
+      prolongation[6](45,46) = -5.0/16.0;
+      prolongation[6](45,47) = 15.0/16.0;
+      prolongation[6](46,27) = 1.0/16.0;
+      prolongation[6](46,29) = 5.0/16.0;
+      prolongation[6](46,45) = -5.0/16.0;
+      prolongation[6](46,47) = 15.0/16.0;
+      prolongation[6](47,1) = 1.0/256.0;
+      prolongation[6](47,2) = 5.0/256.0;
+      prolongation[6](47,5) = 5.0/256.0;
+      prolongation[6](47,6) = 25.0/256.0;
+      prolongation[6](47,10) = -5.0/256.0;
+      prolongation[6](47,11) = 15.0/256.0;
+      prolongation[6](47,18) = -25.0/256.0;
+      prolongation[6](47,19) = 75.0/256.0;
+      prolongation[6](47,26) = -5.0/256.0;
+      prolongation[6](47,27) = 15.0/256.0;
+      prolongation[6](47,28) = -25.0/256.0;
+      prolongation[6](47,29) = 75.0/256.0;
+      prolongation[6](47,44) = 25.0/256.0;
+      prolongation[6](47,45) = -75.0/256.0;
+      prolongation[6](47,46) = -75.0/256.0;
+      prolongation[6](47,47) = 225.0/256.0;
+      prolongation[6](48,51) = 1.0;
+      prolongation[6](49,29) = 5.0/16.0;
+      prolongation[6](49,31) = 1.0/16.0;
+      prolongation[6](49,50) = -5.0/16.0;
+      prolongation[6](49,51) = 15.0/16.0;
+      prolongation[6](50,13) = 1.0/16.0;
+      prolongation[6](50,21) = 5.0/16.0;
+      prolongation[6](50,49) = -5.0/16.0;
+      prolongation[6](50,51) = 15.0/16.0;
+      prolongation[6](51,2) = 5.0/256.0;
+      prolongation[6](51,3) = 1.0/256.0;
+      prolongation[6](51,6) = 25.0/256.0;
+      prolongation[6](51,7) = 5.0/256.0;
+      prolongation[6](51,12) = -5.0/256.0;
+      prolongation[6](51,13) = 15.0/256.0;
+      prolongation[6](51,20) = -25.0/256.0;
+      prolongation[6](51,21) = 75.0/256.0;
+      prolongation[6](51,28) = -25.0/256.0;
+      prolongation[6](51,29) = 75.0/256.0;
+      prolongation[6](51,30) = -5.0/256.0;
+      prolongation[6](51,31) = 15.0/256.0;
+      prolongation[6](51,48) = 25.0/256.0;
+      prolongation[6](51,49) = -75.0/256.0;
+      prolongation[6](51,50) = -75.0/256.0;
+      prolongation[6](51,51) = 225.0/256.0;
+      prolongation[6](52,47) = -1.0/16.0;
+      prolongation[6](52,55) = -1.0/16.0;
+      prolongation[6](52,62) = 9.0/16.0;
+      prolongation[6](52,63) = 9.0/16.0;
+      prolongation[6](53,11) = -1.0/256.0;
+      prolongation[6](53,15) = -1.0/256.0;
+      prolongation[6](53,19) = -5.0/256.0;
+      prolongation[6](53,23) = -5.0/256.0;
+      prolongation[6](53,34) = 9.0/256.0;
+      prolongation[6](53,35) = 9.0/256.0;
+      prolongation[6](53,38) = 45.0/256.0;
+      prolongation[6](53,39) = 45.0/256.0;
+      prolongation[6](53,46) = 5.0/256.0;
+      prolongation[6](53,47) = -15.0/256.0;
+      prolongation[6](53,54) = 5.0/256.0;
+      prolongation[6](53,55) = -15.0/256.0;
+      prolongation[6](53,60) = -45.0/256.0;
+      prolongation[6](53,61) = -45.0/256.0;
+      prolongation[6](53,62) = 135.0/256.0;
+      prolongation[6](53,63) = 135.0/256.0;
+      prolongation[6](54,25) = -1.0/256.0;
+      prolongation[6](54,27) = -1.0/256.0;
+      prolongation[6](54,29) = -5.0/256.0;
+      prolongation[6](54,31) = -5.0/256.0;
+      prolongation[6](54,42) = 9.0/256.0;
+      prolongation[6](54,43) = 9.0/256.0;
+      prolongation[6](54,45) = 5.0/256.0;
+      prolongation[6](54,47) = -15.0/256.0;
+      prolongation[6](54,50) = 45.0/256.0;
+      prolongation[6](54,51) = 45.0/256.0;
+      prolongation[6](54,53) = 5.0/256.0;
+      prolongation[6](54,55) = -15.0/256.0;
+      prolongation[6](54,58) = -45.0/256.0;
+      prolongation[6](54,59) = -45.0/256.0;
+      prolongation[6](54,62) = 135.0/256.0;
+      prolongation[6](54,63) = 135.0/256.0;
+      prolongation[6](55,0) = -1.0/4096.0;
+      prolongation[6](55,1) = -1.0/4096.0;
+      prolongation[6](55,2) = -5.0/4096.0;
+      prolongation[6](55,3) = -5.0/4096.0;
+      prolongation[6](55,4) = -5.0/4096.0;
+      prolongation[6](55,5) = -5.0/4096.0;
+      prolongation[6](55,6) = -25.0/4096.0;
+      prolongation[6](55,7) = -25.0/4096.0;
+      prolongation[6](55,8) = 9.0/4096.0;
+      prolongation[6](55,9) = 9.0/4096.0;
+      prolongation[6](55,10) = 5.0/4096.0;
+      prolongation[6](55,11) = -15.0/4096.0;
+      prolongation[6](55,12) = 45.0/4096.0;
+      prolongation[6](55,13) = 45.0/4096.0;
+      prolongation[6](55,14) = 5.0/4096.0;
+      prolongation[6](55,15) = -15.0/4096.0;
+      prolongation[6](55,16) = 45.0/4096.0;
+      prolongation[6](55,17) = 45.0/4096.0;
+      prolongation[6](55,18) = 25.0/4096.0;
+      prolongation[6](55,19) = -75.0/4096.0;
+      prolongation[6](55,20) = 225.0/4096.0;
+      prolongation[6](55,21) = 225.0/4096.0;
+      prolongation[6](55,22) = 25.0/4096.0;
+      prolongation[6](55,23) = -75.0/4096.0;
+      prolongation[6](55,24) = 5.0/4096.0;
+      prolongation[6](55,25) = -15.0/4096.0;
+      prolongation[6](55,26) = 5.0/4096.0;
+      prolongation[6](55,27) = -15.0/4096.0;
+      prolongation[6](55,28) = 25.0/4096.0;
+      prolongation[6](55,29) = -75.0/4096.0;
+      prolongation[6](55,30) = 25.0/4096.0;
+      prolongation[6](55,31) = -75.0/4096.0;
+      prolongation[6](55,32) = -45.0/4096.0;
+      prolongation[6](55,33) = -45.0/4096.0;
+      prolongation[6](55,34) = 135.0/4096.0;
+      prolongation[6](55,35) = 135.0/4096.0;
+      prolongation[6](55,36) = -225.0/4096.0;
+      prolongation[6](55,37) = -225.0/4096.0;
+      prolongation[6](55,38) = 675.0/4096.0;
+      prolongation[6](55,39) = 675.0/4096.0;
+      prolongation[6](55,40) = -45.0/4096.0;
+      prolongation[6](55,41) = -45.0/4096.0;
+      prolongation[6](55,42) = 135.0/4096.0;
+      prolongation[6](55,43) = 135.0/4096.0;
+      prolongation[6](55,44) = -25.0/4096.0;
+      prolongation[6](55,45) = 75.0/4096.0;
+      prolongation[6](55,46) = 75.0/4096.0;
+      prolongation[6](55,47) = -225.0/4096.0;
+      prolongation[6](55,48) = -225.0/4096.0;
+      prolongation[6](55,49) = -225.0/4096.0;
+      prolongation[6](55,50) = 675.0/4096.0;
+      prolongation[6](55,51) = 675.0/4096.0;
+      prolongation[6](55,52) = -25.0/4096.0;
+      prolongation[6](55,53) = 75.0/4096.0;
+      prolongation[6](55,54) = 75.0/4096.0;
+      prolongation[6](55,55) = -225.0/4096.0;
+      prolongation[6](55,56) = 225.0/4096.0;
+      prolongation[6](55,57) = 225.0/4096.0;
+      prolongation[6](55,58) = -675.0/4096.0;
+      prolongation[6](55,59) = -675.0/4096.0;
+      prolongation[6](55,60) = -675.0/4096.0;
+      prolongation[6](55,61) = -675.0/4096.0;
+      prolongation[6](55,62) = 2025.0/4096.0;
+      prolongation[6](55,63) = 2025.0/4096.0;
+      prolongation[6](56,63) = 1.0;
+      prolongation[6](57,47) = 5.0/16.0;
+      prolongation[6](57,55) = 1.0/16.0;
+      prolongation[6](57,62) = -5.0/16.0;
+      prolongation[6](57,63) = 15.0/16.0;
+      prolongation[6](58,35) = 1.0/16.0;
+      prolongation[6](58,39) = 5.0/16.0;
+      prolongation[6](58,61) = -5.0/16.0;
+      prolongation[6](58,63) = 15.0/16.0;
+      prolongation[6](59,11) = 5.0/256.0;
+      prolongation[6](59,15) = 1.0/256.0;
+      prolongation[6](59,19) = 25.0/256.0;
+      prolongation[6](59,23) = 5.0/256.0;
+      prolongation[6](59,34) = -5.0/256.0;
+      prolongation[6](59,35) = 15.0/256.0;
+      prolongation[6](59,38) = -25.0/256.0;
+      prolongation[6](59,39) = 75.0/256.0;
+      prolongation[6](59,46) = -25.0/256.0;
+      prolongation[6](59,47) = 75.0/256.0;
+      prolongation[6](59,54) = -5.0/256.0;
+      prolongation[6](59,55) = 15.0/256.0;
+      prolongation[6](59,60) = 25.0/256.0;
+      prolongation[6](59,61) = -75.0/256.0;
+      prolongation[6](59,62) = -75.0/256.0;
+      prolongation[6](59,63) = 225.0/256.0;
+      prolongation[6](60,43) = 1.0/16.0;
+      prolongation[6](60,51) = 5.0/16.0;
+      prolongation[6](60,59) = -5.0/16.0;
+      prolongation[6](60,63) = 15.0/16.0;
+      prolongation[6](61,25) = 1.0/256.0;
+      prolongation[6](61,27) = 5.0/256.0;
+      prolongation[6](61,29) = 25.0/256.0;
+      prolongation[6](61,31) = 5.0/256.0;
+      prolongation[6](61,42) = -5.0/256.0;
+      prolongation[6](61,43) = 15.0/256.0;
+      prolongation[6](61,45) = -25.0/256.0;
+      prolongation[6](61,47) = 75.0/256.0;
+      prolongation[6](61,50) = -25.0/256.0;
+      prolongation[6](61,51) = 75.0/256.0;
+      prolongation[6](61,53) = -5.0/256.0;
+      prolongation[6](61,55) = 15.0/256.0;
+      prolongation[6](61,58) = 25.0/256.0;
+      prolongation[6](61,59) = -75.0/256.0;
+      prolongation[6](61,62) = -75.0/256.0;
+      prolongation[6](61,63) = 225.0/256.0;
+      prolongation[6](62,9) = 1.0/256.0;
+      prolongation[6](62,13) = 5.0/256.0;
+      prolongation[6](62,17) = 5.0/256.0;
+      prolongation[6](62,21) = 25.0/256.0;
+      prolongation[6](62,33) = -5.0/256.0;
+      prolongation[6](62,35) = 15.0/256.0;
+      prolongation[6](62,37) = -25.0/256.0;
+      prolongation[6](62,39) = 75.0/256.0;
+      prolongation[6](62,41) = -5.0/256.0;
+      prolongation[6](62,43) = 15.0/256.0;
+      prolongation[6](62,49) = -25.0/256.0;
+      prolongation[6](62,51) = 75.0/256.0;
+      prolongation[6](62,57) = 25.0/256.0;
+      prolongation[6](62,59) = -75.0/256.0;
+      prolongation[6](62,61) = -75.0/256.0;
+      prolongation[6](62,63) = 225.0/256.0;
+      prolongation[6](63,0) = 1.0/4096.0;
+      prolongation[6](63,1) = 5.0/4096.0;
+      prolongation[6](63,2) = 25.0/4096.0;
+      prolongation[6](63,3) = 5.0/4096.0;
+      prolongation[6](63,4) = 5.0/4096.0;
+      prolongation[6](63,5) = 25.0/4096.0;
+      prolongation[6](63,6) = 125.0/4096.0;
+      prolongation[6](63,7) = 25.0/4096.0;
+      prolongation[6](63,8) = -5.0/4096.0;
+      prolongation[6](63,9) = 15.0/4096.0;
+      prolongation[6](63,10) = -25.0/4096.0;
+      prolongation[6](63,11) = 75.0/4096.0;
+      prolongation[6](63,12) = -25.0/4096.0;
+      prolongation[6](63,13) = 75.0/4096.0;
+      prolongation[6](63,14) = -5.0/4096.0;
+      prolongation[6](63,15) = 15.0/4096.0;
+      prolongation[6](63,16) = -25.0/4096.0;
+      prolongation[6](63,17) = 75.0/4096.0;
+      prolongation[6](63,18) = -125.0/4096.0;
+      prolongation[6](63,19) = 375.0/4096.0;
+      prolongation[6](63,20) = -125.0/4096.0;
+      prolongation[6](63,21) = 375.0/4096.0;
+      prolongation[6](63,22) = -25.0/4096.0;
+      prolongation[6](63,23) = 75.0/4096.0;
+      prolongation[6](63,24) = -5.0/4096.0;
+      prolongation[6](63,25) = 15.0/4096.0;
+      prolongation[6](63,26) = -25.0/4096.0;
+      prolongation[6](63,27) = 75.0/4096.0;
+      prolongation[6](63,28) = -125.0/4096.0;
+      prolongation[6](63,29) = 375.0/4096.0;
+      prolongation[6](63,30) = -25.0/4096.0;
+      prolongation[6](63,31) = 75.0/4096.0;
+      prolongation[6](63,32) = 25.0/4096.0;
+      prolongation[6](63,33) = -75.0/4096.0;
+      prolongation[6](63,34) = -75.0/4096.0;
+      prolongation[6](63,35) = 225.0/4096.0;
+      prolongation[6](63,36) = 125.0/4096.0;
+      prolongation[6](63,37) = -375.0/4096.0;
+      prolongation[6](63,38) = -375.0/4096.0;
+      prolongation[6](63,39) = 1125.0/4096.0;
+      prolongation[6](63,40) = 25.0/4096.0;
+      prolongation[6](63,41) = -75.0/4096.0;
+      prolongation[6](63,42) = -75.0/4096.0;
+      prolongation[6](63,43) = 225.0/4096.0;
+      prolongation[6](63,44) = 125.0/4096.0;
+      prolongation[6](63,45) = -375.0/4096.0;
+      prolongation[6](63,46) = -375.0/4096.0;
+      prolongation[6](63,47) = 1125.0/4096.0;
+      prolongation[6](63,48) = 125.0/4096.0;
+      prolongation[6](63,49) = -375.0/4096.0;
+      prolongation[6](63,50) = -375.0/4096.0;
+      prolongation[6](63,51) = 1125.0/4096.0;
+      prolongation[6](63,52) = 25.0/4096.0;
+      prolongation[6](63,53) = -75.0/4096.0;
+      prolongation[6](63,54) = -75.0/4096.0;
+      prolongation[6](63,55) = 225.0/4096.0;
+      prolongation[6](63,56) = -125.0/4096.0;
+      prolongation[6](63,57) = 375.0/4096.0;
+      prolongation[6](63,58) = 375.0/4096.0;
+      prolongation[6](63,59) = -1125.0/4096.0;
+      prolongation[6](63,60) = 375.0/4096.0;
+      prolongation[6](63,61) = -1125.0/4096.0;
+      prolongation[6](63,62) = -1125.0/4096.0;
+      prolongation[6](63,63) = 3375.0/4096.0;
+      prolongation[7](0,0) = 1.0/256.0;
+      prolongation[7](0,3) = 1.0/256.0;
+      prolongation[7](0,4) = 1.0/256.0;
+      prolongation[7](0,7) = 1.0/256.0;
+      prolongation[7](0,14) = -9.0/256.0;
+      prolongation[7](0,15) = -9.0/256.0;
+      prolongation[7](0,22) = -9.0/256.0;
+      prolongation[7](0,23) = -9.0/256.0;
+      prolongation[7](0,24) = -9.0/256.0;
+      prolongation[7](0,25) = -9.0/256.0;
+      prolongation[7](0,30) = -9.0/256.0;
+      prolongation[7](0,31) = -9.0/256.0;
+      prolongation[7](0,52) = 81.0/256.0;
+      prolongation[7](0,53) = 81.0/256.0;
+      prolongation[7](0,54) = 81.0/256.0;
+      prolongation[7](0,55) = 81.0/256.0;
+      prolongation[7](1,0) = -1.0/4096.0;
+      prolongation[7](1,1) = -1.0/4096.0;
+      prolongation[7](1,2) = -1.0/4096.0;
+      prolongation[7](1,3) = -1.0/4096.0;
+      prolongation[7](1,4) = -1.0/4096.0;
+      prolongation[7](1,5) = -1.0/4096.0;
+      prolongation[7](1,6) = -1.0/4096.0;
+      prolongation[7](1,7) = -1.0/4096.0;
+      prolongation[7](1,8) = 9.0/4096.0;
+      prolongation[7](1,9) = 9.0/4096.0;
+      prolongation[7](1,10) = 9.0/4096.0;
+      prolongation[7](1,11) = 9.0/4096.0;
+      prolongation[7](1,12) = 9.0/4096.0;
+      prolongation[7](1,13) = 9.0/4096.0;
+      prolongation[7](1,14) = 9.0/4096.0;
+      prolongation[7](1,15) = 9.0/4096.0;
+      prolongation[7](1,16) = 9.0/4096.0;
+      prolongation[7](1,17) = 9.0/4096.0;
+      prolongation[7](1,18) = 9.0/4096.0;
+      prolongation[7](1,19) = 9.0/4096.0;
+      prolongation[7](1,20) = 9.0/4096.0;
+      prolongation[7](1,21) = 9.0/4096.0;
+      prolongation[7](1,22) = 9.0/4096.0;
+      prolongation[7](1,23) = 9.0/4096.0;
+      prolongation[7](1,24) = 9.0/4096.0;
+      prolongation[7](1,25) = 9.0/4096.0;
+      prolongation[7](1,26) = 9.0/4096.0;
+      prolongation[7](1,27) = 9.0/4096.0;
+      prolongation[7](1,28) = 9.0/4096.0;
+      prolongation[7](1,29) = 9.0/4096.0;
+      prolongation[7](1,30) = 9.0/4096.0;
+      prolongation[7](1,31) = 9.0/4096.0;
+      prolongation[7](1,32) = -81.0/4096.0;
+      prolongation[7](1,33) = -81.0/4096.0;
+      prolongation[7](1,34) = -81.0/4096.0;
+      prolongation[7](1,35) = -81.0/4096.0;
+      prolongation[7](1,36) = -81.0/4096.0;
+      prolongation[7](1,37) = -81.0/4096.0;
+      prolongation[7](1,38) = -81.0/4096.0;
+      prolongation[7](1,39) = -81.0/4096.0;
+      prolongation[7](1,40) = -81.0/4096.0;
+      prolongation[7](1,41) = -81.0/4096.0;
+      prolongation[7](1,42) = -81.0/4096.0;
+      prolongation[7](1,43) = -81.0/4096.0;
+      prolongation[7](1,44) = -81.0/4096.0;
+      prolongation[7](1,45) = -81.0/4096.0;
+      prolongation[7](1,46) = -81.0/4096.0;
+      prolongation[7](1,47) = -81.0/4096.0;
+      prolongation[7](1,48) = -81.0/4096.0;
+      prolongation[7](1,49) = -81.0/4096.0;
+      prolongation[7](1,50) = -81.0/4096.0;
+      prolongation[7](1,51) = -81.0/4096.0;
+      prolongation[7](1,52) = -81.0/4096.0;
+      prolongation[7](1,53) = -81.0/4096.0;
+      prolongation[7](1,54) = -81.0/4096.0;
+      prolongation[7](1,55) = -81.0/4096.0;
+      prolongation[7](1,56) = 729.0/4096.0;
+      prolongation[7](1,57) = 729.0/4096.0;
+      prolongation[7](1,58) = 729.0/4096.0;
+      prolongation[7](1,59) = 729.0/4096.0;
+      prolongation[7](1,60) = 729.0/4096.0;
+      prolongation[7](1,61) = 729.0/4096.0;
+      prolongation[7](1,62) = 729.0/4096.0;
+      prolongation[7](1,63) = 729.0/4096.0;
+      prolongation[7](2,2) = 1.0/256.0;
+      prolongation[7](2,3) = 1.0/256.0;
+      prolongation[7](2,6) = 1.0/256.0;
+      prolongation[7](2,7) = 1.0/256.0;
+      prolongation[7](2,12) = -9.0/256.0;
+      prolongation[7](2,13) = -9.0/256.0;
+      prolongation[7](2,20) = -9.0/256.0;
+      prolongation[7](2,21) = -9.0/256.0;
+      prolongation[7](2,28) = -9.0/256.0;
+      prolongation[7](2,29) = -9.0/256.0;
+      prolongation[7](2,30) = -9.0/256.0;
+      prolongation[7](2,31) = -9.0/256.0;
+      prolongation[7](2,48) = 81.0/256.0;
+      prolongation[7](2,49) = 81.0/256.0;
+      prolongation[7](2,50) = 81.0/256.0;
+      prolongation[7](2,51) = 81.0/256.0;
+      prolongation[7](3,3) = -1.0/16.0;
+      prolongation[7](3,7) = -1.0/16.0;
+      prolongation[7](3,30) = 9.0/16.0;
+      prolongation[7](3,31) = 9.0/16.0;
+      prolongation[7](4,4) = -1.0/16.0;
+      prolongation[7](4,7) = -1.0/16.0;
+      prolongation[7](4,22) = 9.0/16.0;
+      prolongation[7](4,23) = 9.0/16.0;
+      prolongation[7](5,4) = 1.0/256.0;
+      prolongation[7](5,5) = 1.0/256.0;
+      prolongation[7](5,6) = 1.0/256.0;
+      prolongation[7](5,7) = 1.0/256.0;
+      prolongation[7](5,16) = -9.0/256.0;
+      prolongation[7](5,17) = -9.0/256.0;
+      prolongation[7](5,18) = -9.0/256.0;
+      prolongation[7](5,19) = -9.0/256.0;
+      prolongation[7](5,20) = -9.0/256.0;
+      prolongation[7](5,21) = -9.0/256.0;
+      prolongation[7](5,22) = -9.0/256.0;
+      prolongation[7](5,23) = -9.0/256.0;
+      prolongation[7](5,36) = 81.0/256.0;
+      prolongation[7](5,37) = 81.0/256.0;
+      prolongation[7](5,38) = 81.0/256.0;
+      prolongation[7](5,39) = 81.0/256.0;
+      prolongation[7](6,6) = -1.0/16.0;
+      prolongation[7](6,7) = -1.0/16.0;
+      prolongation[7](6,20) = 9.0/16.0;
+      prolongation[7](6,21) = 9.0/16.0;
+      prolongation[7](7,7) = 1.0;
+      prolongation[7](8,0) = 5.0/4096.0;
+      prolongation[7](8,1) = 1.0/4096.0;
+      prolongation[7](8,2) = 1.0/4096.0;
+      prolongation[7](8,3) = 5.0/4096.0;
+      prolongation[7](8,4) = 5.0/4096.0;
+      prolongation[7](8,5) = 1.0/4096.0;
+      prolongation[7](8,6) = 1.0/4096.0;
+      prolongation[7](8,7) = 5.0/4096.0;
+      prolongation[7](8,8) = 15.0/4096.0;
+      prolongation[7](8,9) = -5.0/4096.0;
+      prolongation[7](8,10) = -9.0/4096.0;
+      prolongation[7](8,11) = -9.0/4096.0;
+      prolongation[7](8,12) = 15.0/4096.0;
+      prolongation[7](8,13) = -5.0/4096.0;
+      prolongation[7](8,14) = -45.0/4096.0;
+      prolongation[7](8,15) = -45.0/4096.0;
+      prolongation[7](8,16) = 15.0/4096.0;
+      prolongation[7](8,17) = -5.0/4096.0;
+      prolongation[7](8,18) = -9.0/4096.0;
+      prolongation[7](8,19) = -9.0/4096.0;
+      prolongation[7](8,20) = 15.0/4096.0;
+      prolongation[7](8,21) = -5.0/4096.0;
+      prolongation[7](8,22) = -45.0/4096.0;
+      prolongation[7](8,23) = -45.0/4096.0;
+      prolongation[7](8,24) = -45.0/4096.0;
+      prolongation[7](8,25) = -45.0/4096.0;
+      prolongation[7](8,26) = -9.0/4096.0;
+      prolongation[7](8,27) = -9.0/4096.0;
+      prolongation[7](8,28) = -9.0/4096.0;
+      prolongation[7](8,29) = -9.0/4096.0;
+      prolongation[7](8,30) = -45.0/4096.0;
+      prolongation[7](8,31) = -45.0/4096.0;
+      prolongation[7](8,32) = -135.0/4096.0;
+      prolongation[7](8,33) = 45.0/4096.0;
+      prolongation[7](8,34) = -135.0/4096.0;
+      prolongation[7](8,35) = 45.0/4096.0;
+      prolongation[7](8,36) = -135.0/4096.0;
+      prolongation[7](8,37) = 45.0/4096.0;
+      prolongation[7](8,38) = -135.0/4096.0;
+      prolongation[7](8,39) = 45.0/4096.0;
+      prolongation[7](8,40) = -135.0/4096.0;
+      prolongation[7](8,41) = 45.0/4096.0;
+      prolongation[7](8,42) = -135.0/4096.0;
+      prolongation[7](8,43) = 45.0/4096.0;
+      prolongation[7](8,44) = 81.0/4096.0;
+      prolongation[7](8,45) = 81.0/4096.0;
+      prolongation[7](8,46) = 81.0/4096.0;
+      prolongation[7](8,47) = 81.0/4096.0;
+      prolongation[7](8,48) = -135.0/4096.0;
+      prolongation[7](8,49) = 45.0/4096.0;
+      prolongation[7](8,50) = -135.0/4096.0;
+      prolongation[7](8,51) = 45.0/4096.0;
+      prolongation[7](8,52) = 405.0/4096.0;
+      prolongation[7](8,53) = 405.0/4096.0;
+      prolongation[7](8,54) = 405.0/4096.0;
+      prolongation[7](8,55) = 405.0/4096.0;
+      prolongation[7](8,56) = 1215.0/4096.0;
+      prolongation[7](8,57) = -405.0/4096.0;
+      prolongation[7](8,58) = 1215.0/4096.0;
+      prolongation[7](8,59) = -405.0/4096.0;
+      prolongation[7](8,60) = 1215.0/4096.0;
+      prolongation[7](8,61) = -405.0/4096.0;
+      prolongation[7](8,62) = 1215.0/4096.0;
+      prolongation[7](8,63) = -405.0/4096.0;
+      prolongation[7](9,8) = 1.0/256.0;
+      prolongation[7](9,12) = 1.0/256.0;
+      prolongation[7](9,16) = 1.0/256.0;
+      prolongation[7](9,20) = 1.0/256.0;
+      prolongation[7](9,32) = -9.0/256.0;
+      prolongation[7](9,34) = -9.0/256.0;
+      prolongation[7](9,36) = -9.0/256.0;
+      prolongation[7](9,38) = -9.0/256.0;
+      prolongation[7](9,40) = -9.0/256.0;
+      prolongation[7](9,42) = -9.0/256.0;
+      prolongation[7](9,48) = -9.0/256.0;
+      prolongation[7](9,50) = -9.0/256.0;
+      prolongation[7](9,56) = 81.0/256.0;
+      prolongation[7](9,58) = 81.0/256.0;
+      prolongation[7](9,60) = 81.0/256.0;
+      prolongation[7](9,62) = 81.0/256.0;
+      prolongation[7](10,11) = 1.0/256.0;
+      prolongation[7](10,15) = 1.0/256.0;
+      prolongation[7](10,19) = 1.0/256.0;
+      prolongation[7](10,23) = 1.0/256.0;
+      prolongation[7](10,34) = -9.0/256.0;
+      prolongation[7](10,35) = -9.0/256.0;
+      prolongation[7](10,38) = -9.0/256.0;
+      prolongation[7](10,39) = -9.0/256.0;
+      prolongation[7](10,46) = -9.0/256.0;
+      prolongation[7](10,47) = -9.0/256.0;
+      prolongation[7](10,54) = -9.0/256.0;
+      prolongation[7](10,55) = -9.0/256.0;
+      prolongation[7](10,60) = 81.0/256.0;
+      prolongation[7](10,61) = 81.0/256.0;
+      prolongation[7](10,62) = 81.0/256.0;
+      prolongation[7](10,63) = 81.0/256.0;
+      prolongation[7](11,0) = 1.0/4096.0;
+      prolongation[7](11,1) = 1.0/4096.0;
+      prolongation[7](11,2) = 5.0/4096.0;
+      prolongation[7](11,3) = 5.0/4096.0;
+      prolongation[7](11,4) = 1.0/4096.0;
+      prolongation[7](11,5) = 1.0/4096.0;
+      prolongation[7](11,6) = 5.0/4096.0;
+      prolongation[7](11,7) = 5.0/4096.0;
+      prolongation[7](11,8) = -9.0/4096.0;
+      prolongation[7](11,9) = -9.0/4096.0;
+      prolongation[7](11,10) = -5.0/4096.0;
+      prolongation[7](11,11) = 15.0/4096.0;
+      prolongation[7](11,12) = -45.0/4096.0;
+      prolongation[7](11,13) = -45.0/4096.0;
+      prolongation[7](11,14) = -5.0/4096.0;
+      prolongation[7](11,15) = 15.0/4096.0;
+      prolongation[7](11,16) = -9.0/4096.0;
+      prolongation[7](11,17) = -9.0/4096.0;
+      prolongation[7](11,18) = -5.0/4096.0;
+      prolongation[7](11,19) = 15.0/4096.0;
+      prolongation[7](11,20) = -45.0/4096.0;
+      prolongation[7](11,21) = -45.0/4096.0;
+      prolongation[7](11,22) = -5.0/4096.0;
+      prolongation[7](11,23) = 15.0/4096.0;
+      prolongation[7](11,24) = -9.0/4096.0;
+      prolongation[7](11,25) = -9.0/4096.0;
+      prolongation[7](11,26) = -9.0/4096.0;
+      prolongation[7](11,27) = -9.0/4096.0;
+      prolongation[7](11,28) = -45.0/4096.0;
+      prolongation[7](11,29) = -45.0/4096.0;
+      prolongation[7](11,30) = -45.0/4096.0;
+      prolongation[7](11,31) = -45.0/4096.0;
+      prolongation[7](11,32) = 45.0/4096.0;
+      prolongation[7](11,33) = 45.0/4096.0;
+      prolongation[7](11,34) = -135.0/4096.0;
+      prolongation[7](11,35) = -135.0/4096.0;
+      prolongation[7](11,36) = 45.0/4096.0;
+      prolongation[7](11,37) = 45.0/4096.0;
+      prolongation[7](11,38) = -135.0/4096.0;
+      prolongation[7](11,39) = -135.0/4096.0;
+      prolongation[7](11,40) = 81.0/4096.0;
+      prolongation[7](11,41) = 81.0/4096.0;
+      prolongation[7](11,42) = 81.0/4096.0;
+      prolongation[7](11,43) = 81.0/4096.0;
+      prolongation[7](11,44) = 45.0/4096.0;
+      prolongation[7](11,45) = 45.0/4096.0;
+      prolongation[7](11,46) = -135.0/4096.0;
+      prolongation[7](11,47) = -135.0/4096.0;
+      prolongation[7](11,48) = 405.0/4096.0;
+      prolongation[7](11,49) = 405.0/4096.0;
+      prolongation[7](11,50) = 405.0/4096.0;
+      prolongation[7](11,51) = 405.0/4096.0;
+      prolongation[7](11,52) = 45.0/4096.0;
+      prolongation[7](11,53) = 45.0/4096.0;
+      prolongation[7](11,54) = -135.0/4096.0;
+      prolongation[7](11,55) = -135.0/4096.0;
+      prolongation[7](11,56) = -405.0/4096.0;
+      prolongation[7](11,57) = -405.0/4096.0;
+      prolongation[7](11,58) = -405.0/4096.0;
+      prolongation[7](11,59) = -405.0/4096.0;
+      prolongation[7](11,60) = 1215.0/4096.0;
+      prolongation[7](11,61) = 1215.0/4096.0;
+      prolongation[7](11,62) = 1215.0/4096.0;
+      prolongation[7](11,63) = 1215.0/4096.0;
+      prolongation[7](12,2) = -1.0/256.0;
+      prolongation[7](12,3) = -5.0/256.0;
+      prolongation[7](12,6) = -1.0/256.0;
+      prolongation[7](12,7) = -5.0/256.0;
+      prolongation[7](12,12) = -15.0/256.0;
+      prolongation[7](12,13) = 5.0/256.0;
+      prolongation[7](12,20) = -15.0/256.0;
+      prolongation[7](12,21) = 5.0/256.0;
+      prolongation[7](12,28) = 9.0/256.0;
+      prolongation[7](12,29) = 9.0/256.0;
+      prolongation[7](12,30) = 45.0/256.0;
+      prolongation[7](12,31) = 45.0/256.0;
+      prolongation[7](12,48) = 135.0/256.0;
+      prolongation[7](12,49) = -45.0/256.0;
+      prolongation[7](12,50) = 135.0/256.0;
+      prolongation[7](12,51) = -45.0/256.0;
+      prolongation[7](13,12) = -1.0/16.0;
+      prolongation[7](13,20) = -1.0/16.0;
+      prolongation[7](13,48) = 9.0/16.0;
+      prolongation[7](13,50) = 9.0/16.0;
+      prolongation[7](14,15) = -1.0/16.0;
+      prolongation[7](14,23) = -1.0/16.0;
+      prolongation[7](14,54) = 9.0/16.0;
+      prolongation[7](14,55) = 9.0/16.0;
+      prolongation[7](15,0) = -1.0/256.0;
+      prolongation[7](15,3) = -5.0/256.0;
+      prolongation[7](15,4) = -1.0/256.0;
+      prolongation[7](15,7) = -5.0/256.0;
+      prolongation[7](15,14) = 5.0/256.0;
+      prolongation[7](15,15) = -15.0/256.0;
+      prolongation[7](15,22) = 5.0/256.0;
+      prolongation[7](15,23) = -15.0/256.0;
+      prolongation[7](15,24) = 9.0/256.0;
+      prolongation[7](15,25) = 9.0/256.0;
+      prolongation[7](15,30) = 45.0/256.0;
+      prolongation[7](15,31) = 45.0/256.0;
+      prolongation[7](15,52) = -45.0/256.0;
+      prolongation[7](15,53) = -45.0/256.0;
+      prolongation[7](15,54) = 135.0/256.0;
+      prolongation[7](15,55) = 135.0/256.0;
+      prolongation[7](16,4) = -5.0/256.0;
+      prolongation[7](16,5) = -1.0/256.0;
+      prolongation[7](16,6) = -1.0/256.0;
+      prolongation[7](16,7) = -5.0/256.0;
+      prolongation[7](16,16) = -15.0/256.0;
+      prolongation[7](16,17) = 5.0/256.0;
+      prolongation[7](16,18) = 9.0/256.0;
+      prolongation[7](16,19) = 9.0/256.0;
+      prolongation[7](16,20) = -15.0/256.0;
+      prolongation[7](16,21) = 5.0/256.0;
+      prolongation[7](16,22) = 45.0/256.0;
+      prolongation[7](16,23) = 45.0/256.0;
+      prolongation[7](16,36) = 135.0/256.0;
+      prolongation[7](16,37) = -45.0/256.0;
+      prolongation[7](16,38) = 135.0/256.0;
+      prolongation[7](16,39) = -45.0/256.0;
+      prolongation[7](17,16) = -1.0/16.0;
+      prolongation[7](17,20) = -1.0/16.0;
+      prolongation[7](17,36) = 9.0/16.0;
+      prolongation[7](17,38) = 9.0/16.0;
+      prolongation[7](18,19) = -1.0/16.0;
+      prolongation[7](18,23) = -1.0/16.0;
+      prolongation[7](18,38) = 9.0/16.0;
+      prolongation[7](18,39) = 9.0/16.0;
+      prolongation[7](19,4) = -1.0/256.0;
+      prolongation[7](19,5) = -1.0/256.0;
+      prolongation[7](19,6) = -5.0/256.0;
+      prolongation[7](19,7) = -5.0/256.0;
+      prolongation[7](19,16) = 9.0/256.0;
+      prolongation[7](19,17) = 9.0/256.0;
+      prolongation[7](19,18) = 5.0/256.0;
+      prolongation[7](19,19) = -15.0/256.0;
+      prolongation[7](19,20) = 45.0/256.0;
+      prolongation[7](19,21) = 45.0/256.0;
+      prolongation[7](19,22) = 5.0/256.0;
+      prolongation[7](19,23) = -15.0/256.0;
+      prolongation[7](19,36) = -45.0/256.0;
+      prolongation[7](19,37) = -45.0/256.0;
+      prolongation[7](19,38) = 135.0/256.0;
+      prolongation[7](19,39) = 135.0/256.0;
+      prolongation[7](20,6) = 1.0/16.0;
+      prolongation[7](20,7) = 5.0/16.0;
+      prolongation[7](20,20) = 15.0/16.0;
+      prolongation[7](20,21) = -5.0/16.0;
+      prolongation[7](21,20) = 1.0;
+      prolongation[7](22,23) = 1.0;
+      prolongation[7](23,4) = 1.0/16.0;
+      prolongation[7](23,7) = 5.0/16.0;
+      prolongation[7](23,22) = -5.0/16.0;
+      prolongation[7](23,23) = 15.0/16.0;
+      prolongation[7](24,25) = -1.0/16.0;
+      prolongation[7](24,31) = -1.0/16.0;
+      prolongation[7](24,53) = 9.0/16.0;
+      prolongation[7](24,55) = 9.0/16.0;
+      prolongation[7](25,0) = -1.0/256.0;
+      prolongation[7](25,3) = -1.0/256.0;
+      prolongation[7](25,4) = -5.0/256.0;
+      prolongation[7](25,7) = -5.0/256.0;
+      prolongation[7](25,14) = 9.0/256.0;
+      prolongation[7](25,15) = 9.0/256.0;
+      prolongation[7](25,22) = 45.0/256.0;
+      prolongation[7](25,23) = 45.0/256.0;
+      prolongation[7](25,24) = 5.0/256.0;
+      prolongation[7](25,25) = -15.0/256.0;
+      prolongation[7](25,30) = 5.0/256.0;
+      prolongation[7](25,31) = -15.0/256.0;
+      prolongation[7](25,52) = -45.0/256.0;
+      prolongation[7](25,53) = 135.0/256.0;
+      prolongation[7](25,54) = -45.0/256.0;
+      prolongation[7](25,55) = 135.0/256.0;
+      prolongation[7](26,25) = 1.0/256.0;
+      prolongation[7](26,27) = 1.0/256.0;
+      prolongation[7](26,29) = 1.0/256.0;
+      prolongation[7](26,31) = 1.0/256.0;
+      prolongation[7](26,42) = -9.0/256.0;
+      prolongation[7](26,43) = -9.0/256.0;
+      prolongation[7](26,45) = -9.0/256.0;
+      prolongation[7](26,47) = -9.0/256.0;
+      prolongation[7](26,50) = -9.0/256.0;
+      prolongation[7](26,51) = -9.0/256.0;
+      prolongation[7](26,53) = -9.0/256.0;
+      prolongation[7](26,55) = -9.0/256.0;
+      prolongation[7](26,58) = 81.0/256.0;
+      prolongation[7](26,59) = 81.0/256.0;
+      prolongation[7](26,62) = 81.0/256.0;
+      prolongation[7](26,63) = 81.0/256.0;
+      prolongation[7](27,0) = 1.0/4096.0;
+      prolongation[7](27,1) = 1.0/4096.0;
+      prolongation[7](27,2) = 1.0/4096.0;
+      prolongation[7](27,3) = 1.0/4096.0;
+      prolongation[7](27,4) = 5.0/4096.0;
+      prolongation[7](27,5) = 5.0/4096.0;
+      prolongation[7](27,6) = 5.0/4096.0;
+      prolongation[7](27,7) = 5.0/4096.0;
+      prolongation[7](27,8) = -9.0/4096.0;
+      prolongation[7](27,9) = -9.0/4096.0;
+      prolongation[7](27,10) = -9.0/4096.0;
+      prolongation[7](27,11) = -9.0/4096.0;
+      prolongation[7](27,12) = -9.0/4096.0;
+      prolongation[7](27,13) = -9.0/4096.0;
+      prolongation[7](27,14) = -9.0/4096.0;
+      prolongation[7](27,15) = -9.0/4096.0;
+      prolongation[7](27,16) = -45.0/4096.0;
+      prolongation[7](27,17) = -45.0/4096.0;
+      prolongation[7](27,18) = -45.0/4096.0;
+      prolongation[7](27,19) = -45.0/4096.0;
+      prolongation[7](27,20) = -45.0/4096.0;
+      prolongation[7](27,21) = -45.0/4096.0;
+      prolongation[7](27,22) = -45.0/4096.0;
+      prolongation[7](27,23) = -45.0/4096.0;
+      prolongation[7](27,24) = -5.0/4096.0;
+      prolongation[7](27,25) = 15.0/4096.0;
+      prolongation[7](27,26) = -5.0/4096.0;
+      prolongation[7](27,27) = 15.0/4096.0;
+      prolongation[7](27,28) = -5.0/4096.0;
+      prolongation[7](27,29) = 15.0/4096.0;
+      prolongation[7](27,30) = -5.0/4096.0;
+      prolongation[7](27,31) = 15.0/4096.0;
+      prolongation[7](27,32) = 81.0/4096.0;
+      prolongation[7](27,33) = 81.0/4096.0;
+      prolongation[7](27,34) = 81.0/4096.0;
+      prolongation[7](27,35) = 81.0/4096.0;
+      prolongation[7](27,36) = 405.0/4096.0;
+      prolongation[7](27,37) = 405.0/4096.0;
+      prolongation[7](27,38) = 405.0/4096.0;
+      prolongation[7](27,39) = 405.0/4096.0;
+      prolongation[7](27,40) = 45.0/4096.0;
+      prolongation[7](27,41) = 45.0/4096.0;
+      prolongation[7](27,42) = -135.0/4096.0;
+      prolongation[7](27,43) = -135.0/4096.0;
+      prolongation[7](27,44) = 45.0/4096.0;
+      prolongation[7](27,45) = -135.0/4096.0;
+      prolongation[7](27,46) = 45.0/4096.0;
+      prolongation[7](27,47) = -135.0/4096.0;
+      prolongation[7](27,48) = 45.0/4096.0;
+      prolongation[7](27,49) = 45.0/4096.0;
+      prolongation[7](27,50) = -135.0/4096.0;
+      prolongation[7](27,51) = -135.0/4096.0;
+      prolongation[7](27,52) = 45.0/4096.0;
+      prolongation[7](27,53) = -135.0/4096.0;
+      prolongation[7](27,54) = 45.0/4096.0;
+      prolongation[7](27,55) = -135.0/4096.0;
+      prolongation[7](27,56) = -405.0/4096.0;
+      prolongation[7](27,57) = -405.0/4096.0;
+      prolongation[7](27,58) = 1215.0/4096.0;
+      prolongation[7](27,59) = 1215.0/4096.0;
+      prolongation[7](27,60) = -405.0/4096.0;
+      prolongation[7](27,61) = -405.0/4096.0;
+      prolongation[7](27,62) = 1215.0/4096.0;
+      prolongation[7](27,63) = 1215.0/4096.0;
+      prolongation[7](28,29) = -1.0/16.0;
+      prolongation[7](28,31) = -1.0/16.0;
+      prolongation[7](28,50) = 9.0/16.0;
+      prolongation[7](28,51) = 9.0/16.0;
+      prolongation[7](29,2) = -1.0/256.0;
+      prolongation[7](29,3) = -1.0/256.0;
+      prolongation[7](29,6) = -5.0/256.0;
+      prolongation[7](29,7) = -5.0/256.0;
+      prolongation[7](29,12) = 9.0/256.0;
+      prolongation[7](29,13) = 9.0/256.0;
+      prolongation[7](29,20) = 45.0/256.0;
+      prolongation[7](29,21) = 45.0/256.0;
+      prolongation[7](29,28) = 5.0/256.0;
+      prolongation[7](29,29) = -15.0/256.0;
+      prolongation[7](29,30) = 5.0/256.0;
+      prolongation[7](29,31) = -15.0/256.0;
+      prolongation[7](29,48) = -45.0/256.0;
+      prolongation[7](29,49) = -45.0/256.0;
+      prolongation[7](29,50) = 135.0/256.0;
+      prolongation[7](29,51) = 135.0/256.0;
+      prolongation[7](30,31) = 1.0;
+      prolongation[7](31,3) = 1.0/16.0;
+      prolongation[7](31,7) = 5.0/16.0;
+      prolongation[7](31,30) = -5.0/16.0;
+      prolongation[7](31,31) = 15.0/16.0;
+      prolongation[7](32,11) = -1.0/256.0;
+      prolongation[7](32,15) = -5.0/256.0;
+      prolongation[7](32,19) = -1.0/256.0;
+      prolongation[7](32,23) = -5.0/256.0;
+      prolongation[7](32,34) = -15.0/256.0;
+      prolongation[7](32,35) = 5.0/256.0;
+      prolongation[7](32,38) = -15.0/256.0;
+      prolongation[7](32,39) = 5.0/256.0;
+      prolongation[7](32,46) = 9.0/256.0;
+      prolongation[7](32,47) = 9.0/256.0;
+      prolongation[7](32,54) = 45.0/256.0;
+      prolongation[7](32,55) = 45.0/256.0;
+      prolongation[7](32,60) = 135.0/256.0;
+      prolongation[7](32,61) = -45.0/256.0;
+      prolongation[7](32,62) = 135.0/256.0;
+      prolongation[7](32,63) = -45.0/256.0;
+      prolongation[7](33,34) = -1.0/16.0;
+      prolongation[7](33,38) = -1.0/16.0;
+      prolongation[7](33,60) = 9.0/16.0;
+      prolongation[7](33,62) = 9.0/16.0;
+      prolongation[7](34,0) = -5.0/4096.0;
+      prolongation[7](34,1) = -1.0/4096.0;
+      prolongation[7](34,2) = -5.0/4096.0;
+      prolongation[7](34,3) = -25.0/4096.0;
+      prolongation[7](34,4) = -5.0/4096.0;
+      prolongation[7](34,5) = -1.0/4096.0;
+      prolongation[7](34,6) = -5.0/4096.0;
+      prolongation[7](34,7) = -25.0/4096.0;
+      prolongation[7](34,8) = -15.0/4096.0;
+      prolongation[7](34,9) = 5.0/4096.0;
+      prolongation[7](34,10) = 5.0/4096.0;
+      prolongation[7](34,11) = -15.0/4096.0;
+      prolongation[7](34,12) = -75.0/4096.0;
+      prolongation[7](34,13) = 25.0/4096.0;
+      prolongation[7](34,14) = 25.0/4096.0;
+      prolongation[7](34,15) = -75.0/4096.0;
+      prolongation[7](34,16) = -15.0/4096.0;
+      prolongation[7](34,17) = 5.0/4096.0;
+      prolongation[7](34,18) = 5.0/4096.0;
+      prolongation[7](34,19) = -15.0/4096.0;
+      prolongation[7](34,20) = -75.0/4096.0;
+      prolongation[7](34,21) = 25.0/4096.0;
+      prolongation[7](34,22) = 25.0/4096.0;
+      prolongation[7](34,23) = -75.0/4096.0;
+      prolongation[7](34,24) = 45.0/4096.0;
+      prolongation[7](34,25) = 45.0/4096.0;
+      prolongation[7](34,26) = 9.0/4096.0;
+      prolongation[7](34,27) = 9.0/4096.0;
+      prolongation[7](34,28) = 45.0/4096.0;
+      prolongation[7](34,29) = 45.0/4096.0;
+      prolongation[7](34,30) = 225.0/4096.0;
+      prolongation[7](34,31) = 225.0/4096.0;
+      prolongation[7](34,32) = 75.0/4096.0;
+      prolongation[7](34,33) = -25.0/4096.0;
+      prolongation[7](34,34) = -225.0/4096.0;
+      prolongation[7](34,35) = 75.0/4096.0;
+      prolongation[7](34,36) = 75.0/4096.0;
+      prolongation[7](34,37) = -25.0/4096.0;
+      prolongation[7](34,38) = -225.0/4096.0;
+      prolongation[7](34,39) = 75.0/4096.0;
+      prolongation[7](34,40) = 135.0/4096.0;
+      prolongation[7](34,41) = -45.0/4096.0;
+      prolongation[7](34,42) = 135.0/4096.0;
+      prolongation[7](34,43) = -45.0/4096.0;
+      prolongation[7](34,44) = -45.0/4096.0;
+      prolongation[7](34,45) = -45.0/4096.0;
+      prolongation[7](34,46) = 135.0/4096.0;
+      prolongation[7](34,47) = 135.0/4096.0;
+      prolongation[7](34,48) = 675.0/4096.0;
+      prolongation[7](34,49) = -225.0/4096.0;
+      prolongation[7](34,50) = 675.0/4096.0;
+      prolongation[7](34,51) = -225.0/4096.0;
+      prolongation[7](34,52) = -225.0/4096.0;
+      prolongation[7](34,53) = -225.0/4096.0;
+      prolongation[7](34,54) = 675.0/4096.0;
+      prolongation[7](34,55) = 675.0/4096.0;
+      prolongation[7](34,56) = -675.0/4096.0;
+      prolongation[7](34,57) = 225.0/4096.0;
+      prolongation[7](34,58) = -675.0/4096.0;
+      prolongation[7](34,59) = 225.0/4096.0;
+      prolongation[7](34,60) = 2025.0/4096.0;
+      prolongation[7](34,61) = -675.0/4096.0;
+      prolongation[7](34,62) = 2025.0/4096.0;
+      prolongation[7](34,63) = -675.0/4096.0;
+      prolongation[7](35,8) = -1.0/256.0;
+      prolongation[7](35,12) = -5.0/256.0;
+      prolongation[7](35,16) = -1.0/256.0;
+      prolongation[7](35,20) = -5.0/256.0;
+      prolongation[7](35,32) = 5.0/256.0;
+      prolongation[7](35,34) = -15.0/256.0;
+      prolongation[7](35,36) = 5.0/256.0;
+      prolongation[7](35,38) = -15.0/256.0;
+      prolongation[7](35,40) = 9.0/256.0;
+      prolongation[7](35,42) = 9.0/256.0;
+      prolongation[7](35,48) = 45.0/256.0;
+      prolongation[7](35,50) = 45.0/256.0;
+      prolongation[7](35,56) = -45.0/256.0;
+      prolongation[7](35,58) = -45.0/256.0;
+      prolongation[7](35,60) = 135.0/256.0;
+      prolongation[7](35,62) = 135.0/256.0;
+      prolongation[7](36,19) = 1.0/16.0;
+      prolongation[7](36,23) = 5.0/16.0;
+      prolongation[7](36,38) = 15.0/16.0;
+      prolongation[7](36,39) = -5.0/16.0;
+      prolongation[7](37,38) = 1.0;
+      prolongation[7](38,4) = 5.0/256.0;
+      prolongation[7](38,5) = 1.0/256.0;
+      prolongation[7](38,6) = 5.0/256.0;
+      prolongation[7](38,7) = 25.0/256.0;
+      prolongation[7](38,16) = 15.0/256.0;
+      prolongation[7](38,17) = -5.0/256.0;
+      prolongation[7](38,18) = -5.0/256.0;
+      prolongation[7](38,19) = 15.0/256.0;
+      prolongation[7](38,20) = 75.0/256.0;
+      prolongation[7](38,21) = -25.0/256.0;
+      prolongation[7](38,22) = -25.0/256.0;
+      prolongation[7](38,23) = 75.0/256.0;
+      prolongation[7](38,36) = -75.0/256.0;
+      prolongation[7](38,37) = 25.0/256.0;
+      prolongation[7](38,38) = 225.0/256.0;
+      prolongation[7](38,39) = -75.0/256.0;
+      prolongation[7](39,16) = 1.0/16.0;
+      prolongation[7](39,20) = 5.0/16.0;
+      prolongation[7](39,36) = -5.0/16.0;
+      prolongation[7](39,38) = 15.0/16.0;
+      prolongation[7](40,25) = -5.0/256.0;
+      prolongation[7](40,27) = -1.0/256.0;
+      prolongation[7](40,29) = -1.0/256.0;
+      prolongation[7](40,31) = -5.0/256.0;
+      prolongation[7](40,42) = -15.0/256.0;
+      prolongation[7](40,43) = 5.0/256.0;
+      prolongation[7](40,45) = 9.0/256.0;
+      prolongation[7](40,47) = 9.0/256.0;
+      prolongation[7](40,50) = -15.0/256.0;
+      prolongation[7](40,51) = 5.0/256.0;
+      prolongation[7](40,53) = 45.0/256.0;
+      prolongation[7](40,55) = 45.0/256.0;
+      prolongation[7](40,58) = 135.0/256.0;
+      prolongation[7](40,59) = -45.0/256.0;
+      prolongation[7](40,62) = 135.0/256.0;
+      prolongation[7](40,63) = -45.0/256.0;
+      prolongation[7](41,42) = -1.0/16.0;
+      prolongation[7](41,50) = -1.0/16.0;
+      prolongation[7](41,58) = 9.0/16.0;
+      prolongation[7](41,62) = 9.0/16.0;
+      prolongation[7](42,0) = -5.0/4096.0;
+      prolongation[7](42,1) = -1.0/4096.0;
+      prolongation[7](42,2) = -1.0/4096.0;
+      prolongation[7](42,3) = -5.0/4096.0;
+      prolongation[7](42,4) = -25.0/4096.0;
+      prolongation[7](42,5) = -5.0/4096.0;
+      prolongation[7](42,6) = -5.0/4096.0;
+      prolongation[7](42,7) = -25.0/4096.0;
+      prolongation[7](42,8) = -15.0/4096.0;
+      prolongation[7](42,9) = 5.0/4096.0;
+      prolongation[7](42,10) = 9.0/4096.0;
+      prolongation[7](42,11) = 9.0/4096.0;
+      prolongation[7](42,12) = -15.0/4096.0;
+      prolongation[7](42,13) = 5.0/4096.0;
+      prolongation[7](42,14) = 45.0/4096.0;
+      prolongation[7](42,15) = 45.0/4096.0;
+      prolongation[7](42,16) = -75.0/4096.0;
+      prolongation[7](42,17) = 25.0/4096.0;
+      prolongation[7](42,18) = 45.0/4096.0;
+      prolongation[7](42,19) = 45.0/4096.0;
+      prolongation[7](42,20) = -75.0/4096.0;
+      prolongation[7](42,21) = 25.0/4096.0;
+      prolongation[7](42,22) = 225.0/4096.0;
+      prolongation[7](42,23) = 225.0/4096.0;
+      prolongation[7](42,24) = 25.0/4096.0;
+      prolongation[7](42,25) = -75.0/4096.0;
+      prolongation[7](42,26) = 5.0/4096.0;
+      prolongation[7](42,27) = -15.0/4096.0;
+      prolongation[7](42,28) = 5.0/4096.0;
+      prolongation[7](42,29) = -15.0/4096.0;
+      prolongation[7](42,30) = 25.0/4096.0;
+      prolongation[7](42,31) = -75.0/4096.0;
+      prolongation[7](42,32) = 135.0/4096.0;
+      prolongation[7](42,33) = -45.0/4096.0;
+      prolongation[7](42,34) = 135.0/4096.0;
+      prolongation[7](42,35) = -45.0/4096.0;
+      prolongation[7](42,36) = 675.0/4096.0;
+      prolongation[7](42,37) = -225.0/4096.0;
+      prolongation[7](42,38) = 675.0/4096.0;
+      prolongation[7](42,39) = -225.0/4096.0;
+      prolongation[7](42,40) = 75.0/4096.0;
+      prolongation[7](42,41) = -25.0/4096.0;
+      prolongation[7](42,42) = -225.0/4096.0;
+      prolongation[7](42,43) = 75.0/4096.0;
+      prolongation[7](42,44) = -45.0/4096.0;
+      prolongation[7](42,45) = 135.0/4096.0;
+      prolongation[7](42,46) = -45.0/4096.0;
+      prolongation[7](42,47) = 135.0/4096.0;
+      prolongation[7](42,48) = 75.0/4096.0;
+      prolongation[7](42,49) = -25.0/4096.0;
+      prolongation[7](42,50) = -225.0/4096.0;
+      prolongation[7](42,51) = 75.0/4096.0;
+      prolongation[7](42,52) = -225.0/4096.0;
+      prolongation[7](42,53) = 675.0/4096.0;
+      prolongation[7](42,54) = -225.0/4096.0;
+      prolongation[7](42,55) = 675.0/4096.0;
+      prolongation[7](42,56) = -675.0/4096.0;
+      prolongation[7](42,57) = 225.0/4096.0;
+      prolongation[7](42,58) = 2025.0/4096.0;
+      prolongation[7](42,59) = -675.0/4096.0;
+      prolongation[7](42,60) = -675.0/4096.0;
+      prolongation[7](42,61) = 225.0/4096.0;
+      prolongation[7](42,62) = 2025.0/4096.0;
+      prolongation[7](42,63) = -675.0/4096.0;
+      prolongation[7](43,8) = -1.0/256.0;
+      prolongation[7](43,12) = -1.0/256.0;
+      prolongation[7](43,16) = -5.0/256.0;
+      prolongation[7](43,20) = -5.0/256.0;
+      prolongation[7](43,32) = 9.0/256.0;
+      prolongation[7](43,34) = 9.0/256.0;
+      prolongation[7](43,36) = 45.0/256.0;
+      prolongation[7](43,38) = 45.0/256.0;
+      prolongation[7](43,40) = 5.0/256.0;
+      prolongation[7](43,42) = -15.0/256.0;
+      prolongation[7](43,48) = 5.0/256.0;
+      prolongation[7](43,50) = -15.0/256.0;
+      prolongation[7](43,56) = -45.0/256.0;
+      prolongation[7](43,58) = 135.0/256.0;
+      prolongation[7](43,60) = -45.0/256.0;
+      prolongation[7](43,62) = 135.0/256.0;
+      prolongation[7](44,47) = -1.0/16.0;
+      prolongation[7](44,55) = -1.0/16.0;
+      prolongation[7](44,62) = 9.0/16.0;
+      prolongation[7](44,63) = 9.0/16.0;
+      prolongation[7](45,11) = -1.0/256.0;
+      prolongation[7](45,15) = -1.0/256.0;
+      prolongation[7](45,19) = -5.0/256.0;
+      prolongation[7](45,23) = -5.0/256.0;
+      prolongation[7](45,34) = 9.0/256.0;
+      prolongation[7](45,35) = 9.0/256.0;
+      prolongation[7](45,38) = 45.0/256.0;
+      prolongation[7](45,39) = 45.0/256.0;
+      prolongation[7](45,46) = 5.0/256.0;
+      prolongation[7](45,47) = -15.0/256.0;
+      prolongation[7](45,54) = 5.0/256.0;
+      prolongation[7](45,55) = -15.0/256.0;
+      prolongation[7](45,60) = -45.0/256.0;
+      prolongation[7](45,61) = -45.0/256.0;
+      prolongation[7](45,62) = 135.0/256.0;
+      prolongation[7](45,63) = 135.0/256.0;
+      prolongation[7](46,25) = -1.0/256.0;
+      prolongation[7](46,27) = -1.0/256.0;
+      prolongation[7](46,29) = -5.0/256.0;
+      prolongation[7](46,31) = -5.0/256.0;
+      prolongation[7](46,42) = 9.0/256.0;
+      prolongation[7](46,43) = 9.0/256.0;
+      prolongation[7](46,45) = 5.0/256.0;
+      prolongation[7](46,47) = -15.0/256.0;
+      prolongation[7](46,50) = 45.0/256.0;
+      prolongation[7](46,51) = 45.0/256.0;
+      prolongation[7](46,53) = 5.0/256.0;
+      prolongation[7](46,55) = -15.0/256.0;
+      prolongation[7](46,58) = -45.0/256.0;
+      prolongation[7](46,59) = -45.0/256.0;
+      prolongation[7](46,62) = 135.0/256.0;
+      prolongation[7](46,63) = 135.0/256.0;
+      prolongation[7](47,0) = -1.0/4096.0;
+      prolongation[7](47,1) = -1.0/4096.0;
+      prolongation[7](47,2) = -5.0/4096.0;
+      prolongation[7](47,3) = -5.0/4096.0;
+      prolongation[7](47,4) = -5.0/4096.0;
+      prolongation[7](47,5) = -5.0/4096.0;
+      prolongation[7](47,6) = -25.0/4096.0;
+      prolongation[7](47,7) = -25.0/4096.0;
+      prolongation[7](47,8) = 9.0/4096.0;
+      prolongation[7](47,9) = 9.0/4096.0;
+      prolongation[7](47,10) = 5.0/4096.0;
+      prolongation[7](47,11) = -15.0/4096.0;
+      prolongation[7](47,12) = 45.0/4096.0;
+      prolongation[7](47,13) = 45.0/4096.0;
+      prolongation[7](47,14) = 5.0/4096.0;
+      prolongation[7](47,15) = -15.0/4096.0;
+      prolongation[7](47,16) = 45.0/4096.0;
+      prolongation[7](47,17) = 45.0/4096.0;
+      prolongation[7](47,18) = 25.0/4096.0;
+      prolongation[7](47,19) = -75.0/4096.0;
+      prolongation[7](47,20) = 225.0/4096.0;
+      prolongation[7](47,21) = 225.0/4096.0;
+      prolongation[7](47,22) = 25.0/4096.0;
+      prolongation[7](47,23) = -75.0/4096.0;
+      prolongation[7](47,24) = 5.0/4096.0;
+      prolongation[7](47,25) = -15.0/4096.0;
+      prolongation[7](47,26) = 5.0/4096.0;
+      prolongation[7](47,27) = -15.0/4096.0;
+      prolongation[7](47,28) = 25.0/4096.0;
+      prolongation[7](47,29) = -75.0/4096.0;
+      prolongation[7](47,30) = 25.0/4096.0;
+      prolongation[7](47,31) = -75.0/4096.0;
+      prolongation[7](47,32) = -45.0/4096.0;
+      prolongation[7](47,33) = -45.0/4096.0;
+      prolongation[7](47,34) = 135.0/4096.0;
+      prolongation[7](47,35) = 135.0/4096.0;
+      prolongation[7](47,36) = -225.0/4096.0;
+      prolongation[7](47,37) = -225.0/4096.0;
+      prolongation[7](47,38) = 675.0/4096.0;
+      prolongation[7](47,39) = 675.0/4096.0;
+      prolongation[7](47,40) = -45.0/4096.0;
+      prolongation[7](47,41) = -45.0/4096.0;
+      prolongation[7](47,42) = 135.0/4096.0;
+      prolongation[7](47,43) = 135.0/4096.0;
+      prolongation[7](47,44) = -25.0/4096.0;
+      prolongation[7](47,45) = 75.0/4096.0;
+      prolongation[7](47,46) = 75.0/4096.0;
+      prolongation[7](47,47) = -225.0/4096.0;
+      prolongation[7](47,48) = -225.0/4096.0;
+      prolongation[7](47,49) = -225.0/4096.0;
+      prolongation[7](47,50) = 675.0/4096.0;
+      prolongation[7](47,51) = 675.0/4096.0;
+      prolongation[7](47,52) = -25.0/4096.0;
+      prolongation[7](47,53) = 75.0/4096.0;
+      prolongation[7](47,54) = 75.0/4096.0;
+      prolongation[7](47,55) = -225.0/4096.0;
+      prolongation[7](47,56) = 225.0/4096.0;
+      prolongation[7](47,57) = 225.0/4096.0;
+      prolongation[7](47,58) = -675.0/4096.0;
+      prolongation[7](47,59) = -675.0/4096.0;
+      prolongation[7](47,60) = -675.0/4096.0;
+      prolongation[7](47,61) = -675.0/4096.0;
+      prolongation[7](47,62) = 2025.0/4096.0;
+      prolongation[7](47,63) = 2025.0/4096.0;
+      prolongation[7](48,29) = 1.0/16.0;
+      prolongation[7](48,31) = 5.0/16.0;
+      prolongation[7](48,50) = 15.0/16.0;
+      prolongation[7](48,51) = -5.0/16.0;
+      prolongation[7](49,50) = 1.0;
+      prolongation[7](50,2) = 1.0/256.0;
+      prolongation[7](50,3) = 5.0/256.0;
+      prolongation[7](50,6) = 5.0/256.0;
+      prolongation[7](50,7) = 25.0/256.0;
+      prolongation[7](50,12) = 15.0/256.0;
+      prolongation[7](50,13) = -5.0/256.0;
+      prolongation[7](50,20) = 75.0/256.0;
+      prolongation[7](50,21) = -25.0/256.0;
+      prolongation[7](50,28) = -5.0/256.0;
+      prolongation[7](50,29) = 15.0/256.0;
+      prolongation[7](50,30) = -25.0/256.0;
+      prolongation[7](50,31) = 75.0/256.0;
+      prolongation[7](50,48) = -75.0/256.0;
+      prolongation[7](50,49) = 25.0/256.0;
+      prolongation[7](50,50) = 225.0/256.0;
+      prolongation[7](50,51) = -75.0/256.0;
+      prolongation[7](51,12) = 1.0/16.0;
+      prolongation[7](51,20) = 5.0/16.0;
+      prolongation[7](51,48) = -5.0/16.0;
+      prolongation[7](51,50) = 15.0/16.0;
+      prolongation[7](52,55) = 1.0;
+      prolongation[7](53,15) = 1.0/16.0;
+      prolongation[7](53,23) = 5.0/16.0;
+      prolongation[7](53,54) = -5.0/16.0;
+      prolongation[7](53,55) = 15.0/16.0;
+      prolongation[7](54,25) = 1.0/16.0;
+      prolongation[7](54,31) = 5.0/16.0;
+      prolongation[7](54,53) = -5.0/16.0;
+      prolongation[7](54,55) = 15.0/16.0;
+      prolongation[7](55,0) = 1.0/256.0;
+      prolongation[7](55,3) = 5.0/256.0;
+      prolongation[7](55,4) = 5.0/256.0;
+      prolongation[7](55,7) = 25.0/256.0;
+      prolongation[7](55,14) = -5.0/256.0;
+      prolongation[7](55,15) = 15.0/256.0;
+      prolongation[7](55,22) = -25.0/256.0;
+      prolongation[7](55,23) = 75.0/256.0;
+      prolongation[7](55,24) = -5.0/256.0;
+      prolongation[7](55,25) = 15.0/256.0;
+      prolongation[7](55,30) = -25.0/256.0;
+      prolongation[7](55,31) = 75.0/256.0;
+      prolongation[7](55,52) = 25.0/256.0;
+      prolongation[7](55,53) = -75.0/256.0;
+      prolongation[7](55,54) = -75.0/256.0;
+      prolongation[7](55,55) = 225.0/256.0;
+      prolongation[7](56,47) = 1.0/16.0;
+      prolongation[7](56,55) = 5.0/16.0;
+      prolongation[7](56,62) = 15.0/16.0;
+      prolongation[7](56,63) = -5.0/16.0;
+      prolongation[7](57,62) = 1.0;
+      prolongation[7](58,11) = 1.0/256.0;
+      prolongation[7](58,15) = 5.0/256.0;
+      prolongation[7](58,19) = 5.0/256.0;
+      prolongation[7](58,23) = 25.0/256.0;
+      prolongation[7](58,34) = 15.0/256.0;
+      prolongation[7](58,35) = -5.0/256.0;
+      prolongation[7](58,38) = 75.0/256.0;
+      prolongation[7](58,39) = -25.0/256.0;
+      prolongation[7](58,46) = -5.0/256.0;
+      prolongation[7](58,47) = 15.0/256.0;
+      prolongation[7](58,54) = -25.0/256.0;
+      prolongation[7](58,55) = 75.0/256.0;
+      prolongation[7](58,60) = -75.0/256.0;
+      prolongation[7](58,61) = 25.0/256.0;
+      prolongation[7](58,62) = 225.0/256.0;
+      prolongation[7](58,63) = -75.0/256.0;
+      prolongation[7](59,34) = 1.0/16.0;
+      prolongation[7](59,38) = 5.0/16.0;
+      prolongation[7](59,60) = -5.0/16.0;
+      prolongation[7](59,62) = 15.0/16.0;
+      prolongation[7](60,25) = 5.0/256.0;
+      prolongation[7](60,27) = 1.0/256.0;
+      prolongation[7](60,29) = 5.0/256.0;
+      prolongation[7](60,31) = 25.0/256.0;
+      prolongation[7](60,42) = 15.0/256.0;
+      prolongation[7](60,43) = -5.0/256.0;
+      prolongation[7](60,45) = -5.0/256.0;
+      prolongation[7](60,47) = 15.0/256.0;
+      prolongation[7](60,50) = 75.0/256.0;
+      prolongation[7](60,51) = -25.0/256.0;
+      prolongation[7](60,53) = -25.0/256.0;
+      prolongation[7](60,55) = 75.0/256.0;
+      prolongation[7](60,58) = -75.0/256.0;
+      prolongation[7](60,59) = 25.0/256.0;
+      prolongation[7](60,62) = 225.0/256.0;
+      prolongation[7](60,63) = -75.0/256.0;
+      prolongation[7](61,42) = 1.0/16.0;
+      prolongation[7](61,50) = 5.0/16.0;
+      prolongation[7](61,58) = -5.0/16.0;
+      prolongation[7](61,62) = 15.0/16.0;
+      prolongation[7](62,0) = 5.0/4096.0;
+      prolongation[7](62,1) = 1.0/4096.0;
+      prolongation[7](62,2) = 5.0/4096.0;
+      prolongation[7](62,3) = 25.0/4096.0;
+      prolongation[7](62,4) = 25.0/4096.0;
+      prolongation[7](62,5) = 5.0/4096.0;
+      prolongation[7](62,6) = 25.0/4096.0;
+      prolongation[7](62,7) = 125.0/4096.0;
+      prolongation[7](62,8) = 15.0/4096.0;
+      prolongation[7](62,9) = -5.0/4096.0;
+      prolongation[7](62,10) = -5.0/4096.0;
+      prolongation[7](62,11) = 15.0/4096.0;
+      prolongation[7](62,12) = 75.0/4096.0;
+      prolongation[7](62,13) = -25.0/4096.0;
+      prolongation[7](62,14) = -25.0/4096.0;
+      prolongation[7](62,15) = 75.0/4096.0;
+      prolongation[7](62,16) = 75.0/4096.0;
+      prolongation[7](62,17) = -25.0/4096.0;
+      prolongation[7](62,18) = -25.0/4096.0;
+      prolongation[7](62,19) = 75.0/4096.0;
+      prolongation[7](62,20) = 375.0/4096.0;
+      prolongation[7](62,21) = -125.0/4096.0;
+      prolongation[7](62,22) = -125.0/4096.0;
+      prolongation[7](62,23) = 375.0/4096.0;
+      prolongation[7](62,24) = -25.0/4096.0;
+      prolongation[7](62,25) = 75.0/4096.0;
+      prolongation[7](62,26) = -5.0/4096.0;
+      prolongation[7](62,27) = 15.0/4096.0;
+      prolongation[7](62,28) = -25.0/4096.0;
+      prolongation[7](62,29) = 75.0/4096.0;
+      prolongation[7](62,30) = -125.0/4096.0;
+      prolongation[7](62,31) = 375.0/4096.0;
+      prolongation[7](62,32) = -75.0/4096.0;
+      prolongation[7](62,33) = 25.0/4096.0;
+      prolongation[7](62,34) = 225.0/4096.0;
+      prolongation[7](62,35) = -75.0/4096.0;
+      prolongation[7](62,36) = -375.0/4096.0;
+      prolongation[7](62,37) = 125.0/4096.0;
+      prolongation[7](62,38) = 1125.0/4096.0;
+      prolongation[7](62,39) = -375.0/4096.0;
+      prolongation[7](62,40) = -75.0/4096.0;
+      prolongation[7](62,41) = 25.0/4096.0;
+      prolongation[7](62,42) = 225.0/4096.0;
+      prolongation[7](62,43) = -75.0/4096.0;
+      prolongation[7](62,44) = 25.0/4096.0;
+      prolongation[7](62,45) = -75.0/4096.0;
+      prolongation[7](62,46) = -75.0/4096.0;
+      prolongation[7](62,47) = 225.0/4096.0;
+      prolongation[7](62,48) = -375.0/4096.0;
+      prolongation[7](62,49) = 125.0/4096.0;
+      prolongation[7](62,50) = 1125.0/4096.0;
+      prolongation[7](62,51) = -375.0/4096.0;
+      prolongation[7](62,52) = 125.0/4096.0;
+      prolongation[7](62,53) = -375.0/4096.0;
+      prolongation[7](62,54) = -375.0/4096.0;
+      prolongation[7](62,55) = 1125.0/4096.0;
+      prolongation[7](62,56) = 375.0/4096.0;
+      prolongation[7](62,57) = -125.0/4096.0;
+      prolongation[7](62,58) = -1125.0/4096.0;
+      prolongation[7](62,59) = 375.0/4096.0;
+      prolongation[7](62,60) = -1125.0/4096.0;
+      prolongation[7](62,61) = 375.0/4096.0;
+      prolongation[7](62,62) = 3375.0/4096.0;
+      prolongation[7](62,63) = -1125.0/4096.0;
+      prolongation[7](63,8) = 1.0/256.0;
+      prolongation[7](63,12) = 5.0/256.0;
+      prolongation[7](63,16) = 5.0/256.0;
+      prolongation[7](63,20) = 25.0/256.0;
+      prolongation[7](63,32) = -5.0/256.0;
+      prolongation[7](63,34) = 15.0/256.0;
+      prolongation[7](63,36) = -25.0/256.0;
+      prolongation[7](63,38) = 75.0/256.0;
+      prolongation[7](63,40) = -5.0/256.0;
+      prolongation[7](63,42) = 15.0/256.0;
+      prolongation[7](63,48) = -25.0/256.0;
+      prolongation[7](63,50) = 75.0/256.0;
+      prolongation[7](63,56) = 25.0/256.0;
+      prolongation[7](63,58) = -75.0/256.0;
+      prolongation[7](63,60) = -75.0/256.0;
+      prolongation[7](63,62) = 225.0/256.0;
+
+
+      restriction[0](0,0) = 1.0;
+      restriction[0](8,9) = 1.0;
+      restriction[0](14,15) = 1.0;
+      restriction[0](24,25) = 1.0;
+      restriction[0](32,35) = 1.0;
+      restriction[0](40,43) = 1.0;
+      restriction[0](52,55) = 1.0;
+      restriction[0](56,63) = 1.0;
+      restriction[1](1,1) = 1.0;
+      restriction[1](9,8) = 1.0;
+      restriction[1](10,11) = 1.0;
+      restriction[1](26,27) = 1.0;
+      restriction[1](33,34) = 1.0;
+      restriction[1](41,42) = 1.0;
+      restriction[1](44,47) = 1.0;
+      restriction[1](57,62) = 1.0;
+      restriction[2](2,2) = 1.0;
+      restriction[2](11,10) = 1.0;
+      restriction[2](13,12) = 1.0;
+      restriction[2](28,29) = 1.0;
+      restriction[2](35,32) = 1.0;
+      restriction[2](46,45) = 1.0;
+      restriction[2](49,50) = 1.0;
+      restriction[2](61,58) = 1.0;
+      restriction[3](3,3) = 1.0;
+      restriction[3](12,13) = 1.0;
+      restriction[3](15,14) = 1.0;
+      restriction[3](30,31) = 1.0;
+      restriction[3](34,33) = 1.0;
+      restriction[3](48,51) = 1.0;
+      restriction[3](54,53) = 1.0;
+      restriction[3](60,59) = 1.0;
+      restriction[4](4,4) = 1.0;
+      restriction[4](16,17) = 1.0;
+      restriction[4](22,23) = 1.0;
+      restriction[4](25,24) = 1.0;
+      restriction[4](36,39) = 1.0;
+      restriction[4](42,41) = 1.0;
+      restriction[4](53,54) = 1.0;
+      restriction[4](58,61) = 1.0;
+      restriction[5](5,5) = 1.0;
+      restriction[5](17,16) = 1.0;
+      restriction[5](18,19) = 1.0;
+      restriction[5](27,26) = 1.0;
+      restriction[5](37,38) = 1.0;
+      restriction[5](43,40) = 1.0;
+      restriction[5](45,46) = 1.0;
+      restriction[5](59,60) = 1.0;
+      restriction[6](6,6) = 1.0;
+      restriction[6](19,18) = 1.0;
+      restriction[6](21,20) = 1.0;
+      restriction[6](29,28) = 1.0;
+      restriction[6](39,36) = 1.0;
+      restriction[6](47,44) = 1.0;
+      restriction[6](51,48) = 1.0;
+      restriction[6](63,56) = 1.0;
+      restriction[7](7,7) = 1.0;
+      restriction[7](20,21) = 1.0;
+      restriction[7](23,22) = 1.0;
+      restriction[7](31,30) = 1.0;
+      restriction[7](38,37) = 1.0;
+      restriction[7](50,49) = 1.0;
+      restriction[7](55,52) = 1.0;
+      restriction[7](62,57) = 1.0;
+};
+
+
+
+template <>
+double
+FECubicSub<3>::shape_value (const unsigned int i,
+                           const Point<3>    &p) const
+{
+  Assert (i<total_dofs, ExcInvalidIndex(i));
+
+  const double xi  = p(0),
+              eta = p(1),
+              zeta=p(2);
+  switch (i)
+    {
+      case 0: return 1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+(-11.0/2.0+
+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi)*eta+(9.0-99.0/2.0*xi+81.0*xi*xi
+-81.0/2.0*xi*xi*xi)*eta*eta+(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi
+*xi)*eta*eta*eta+(-11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+(
+121.0/4.0-1331.0/8.0*xi+1089.0/4.0*xi*xi-1089.0/8.0*xi*xi*xi)*eta+(-99.0/2.0+
+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta*eta+(99.0/4.0-1089.0/8.0*
+xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+(9.0-99.0/2.0*xi+81.0*
+xi*xi-81.0/2.0*xi*xi*xi+(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*
+xi*xi)*eta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(-81.0/
+2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(
+-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+(99.0/4.0-1089.0/8.0*xi+
+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi
++729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*
+xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 1: return xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+(-11.0/2.0*xi+99.0/4.0
+*xi*xi-99.0/4.0*xi*xi*xi)*eta+(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta*eta
++(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta+(-11.0/2.0*xi+99.0/
+4.0*xi*xi-99.0/4.0*xi*xi*xi+(121.0/4.0*xi-1089.0/8.0*xi*xi+1089.0/8.0*xi*xi*xi)
+*eta+(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta*eta+(99.0/4.0*xi
+-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+(9.0*xi-81.0/2.0*xi*xi+
+81.0/2.0*xi*xi*xi+(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta+(81.0*
+xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi
+-729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/
+4.0*xi*xi*xi+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0*xi
++729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0
+/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 2: return (xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+(-11.0/2.0*xi+99.0/
+4.0*xi*xi-99.0/4.0*xi*xi*xi)*eta+(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta*
+eta+(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+(-9.0/2.0*
+xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*
+xi*xi)*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0*
+xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(9.0/2.0*xi-81.0/
+4.0*xi*xi+81.0/4.0*xi*xi*xi+(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi)*
+eta+(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+
+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 3: return (1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+(-11.0/2.0+
+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi)*eta+(9.0-99.0/2.0*xi+81.0*xi*xi
+-81.0/2.0*xi*xi*xi)*eta*eta+(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi
+*xi)*eta*eta*eta)*zeta+(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+(
+99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0+891.0
+/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0-891.0/8.0*xi+
+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(9.0/2.0-99.0/4.0*xi
++81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi+(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+
+891.0/8.0*xi*xi*xi)*eta+(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*
+xi)*eta*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta
+*eta)*zeta*zeta*zeta;
+      case 4: return (1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi)*eta+(-9.0/
+2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0-99.0/4.0*xi+
+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta+((-11.0/2.0+121.0/4.0*xi-99.0/2.0
+*xi*xi+99.0/4.0*xi*xi*xi)*eta+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0
+*xi*xi*xi)*eta*eta+(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi)
+*eta*eta*eta)*zeta+((9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+(-81.0/
+2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0-891.0/
+4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-9.0/2.0+
+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(81.0/4.0-891.0/8.0*xi+729.0/
+4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+
+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 5: return (xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi)*eta+(-9.0/2.0*xi+
+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*
+xi*xi*xi)*eta*eta*eta+((-11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi)*eta+(
+99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta+(-99.0/4.0*xi+891.0/8.0
+*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((9.0*xi-81.0/2.0*xi*xi+81.0/2.0*
+xi*xi*xi)*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/
+2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-9.0/2.0*xi
++81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*
+xi*xi*xi)*eta*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta
+)*zeta*zeta*zeta;
+      case 6: return ((xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi)*eta+(-9.0/2.0*xi+
+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*
+xi*xi*xi)*eta*eta*eta)*zeta+((-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta
++(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+729.0/
+8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((9.0/2.0*xi-81.0/4.0*xi*
+xi+81.0/4.0*xi*xi*xi)*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta
+*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*
+zeta;
+      case 7: return ((1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi)*eta+(-9.0/
+2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0-99.0/4.0*xi+
+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-9.0/2.0+99.0/4.0*xi-81.0
+/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/
+8.0*xi*xi*xi)*eta*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*
+xi)*eta*eta*eta)*zeta*zeta+((9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*
+xi)*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+(
+81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*
+zeta*zeta;
+      case 8: return 9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+(-99.0/2.0*xi+
+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi)*eta+(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*
+xi*xi)*eta*eta+(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta+(
+-99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+(1089.0/4.0*xi-5445.0/8.0*xi*xi
++3267.0/8.0*xi*xi*xi)*eta+(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*
+eta*eta+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+(
+81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+(-891.0/2.0*xi+4455.0/4.0*xi*xi
+-2673.0/4.0*xi*xi*xi)*eta+(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*
+eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta
++(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0/4.0*xi-4455.0/8.0*xi*
+xi+2673.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi
+)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta
+*zeta*zeta;
+      case 9: return -9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+(99.0/4.0*xi
+-99.0*xi*xi+297.0/4.0*xi*xi*xi)*eta+(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*
+xi)*eta*eta+(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta+(99.0/4.0*
+xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+(-1089.0/8.0*xi+1089.0/2.0*xi*xi-3267.0/8.0*xi
+*xi*xi)*eta+(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta*eta+(-891.0/8.0*
+xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+(-81.0/2.0*xi+162.0*
+xi*xi-243.0/2.0*xi*xi*xi+(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta+(
+-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-729.0*xi*
+xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(81.0/4.0*xi-81.0*xi*xi+243.0/
+4.0*xi*xi*xi+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(729.0/4.0
+*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi
+-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 10: return (9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+(-99.0/2.0*xi+
+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta+(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*
+xi*xi)*eta*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta)*
+zeta+(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi+(495.0/4.0*xi-4455.0/8.0*
+xi*xi+4455.0/8.0*xi*xi*xi)*eta+(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi
+*xi)*eta*eta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta*eta)*
+zeta*zeta+(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+(-297.0/4.0*xi+2673.0
+/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*
+xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*
+eta)*zeta*zeta*zeta;
+      case 11: return (-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+(99.0/4.0
+*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0
+/4.0*xi*xi*xi)*eta*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta
+*eta)*zeta+(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi+(-99.0*xi+891.0/2.0*xi*xi-891.0/
+2.0*xi*xi*xi)*eta+(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta*eta+(-81.0*xi+729.0
+/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(-27.0/2.0*xi+243.0/4.0*
+xi*xi-243.0/4.0*xi*xi*xi+(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*
+eta+(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi
+-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 12: return (9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+(-99.0/2.0*xi+
+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi)*eta+(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*
+xi*xi)*eta*eta+(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta)*
+zeta+(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0/4.0*xi-4455.0/8.0*
+xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi
+*xi)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*
+zeta*zeta+(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+(-891.0/4.0*xi+4455.0
+/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*
+xi*xi*xi)*eta*eta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*
+eta)*zeta*zeta*zeta;
+      case 13: return (-9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+(99.0/4.0*xi
+-99.0*xi*xi+297.0/4.0*xi*xi*xi)*eta+(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*
+xi)*eta*eta+(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+(81.0
+/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0
+*xi*xi*xi)*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/
+8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(-81.0/4.0*
+xi+81.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi
+*xi)*eta+(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi
+-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 14: return (9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+(-99.0/
+2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta+(81.0-891.0/2.0*xi+
+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi
++729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+
+405.0/4.0*xi*xi*xi+(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*
+xi)*eta+(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta*eta
++(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta*eta)*
+zeta*zeta+(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi+(-297.0/4.0
++3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(243.0/2.0-2673.0/4.0*
+xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi
+-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 15: return (-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+
+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0+
+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0-891.0/8.0*xi
++729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+(18.0-99.0*xi+162.0*xi*
+xi-81.0*xi*xi*xi+(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi)*eta+(
+162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta*eta+(-81.0+891.0/2.0*xi-729.0*
+xi*xi+729.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(-27.0/2.0+297.0/4.0*xi-243.0/
+2.0*xi*xi+243.0/4.0*xi*xi*xi+(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/
+8.0*xi*xi*xi)*eta+(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*
+xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*
+eta*eta)*zeta*zeta*zeta;
+      case 16: return (9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi)*eta+(-81.0/
+2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0*xi-405.0/4.0*xi*xi
++243.0/4.0*xi*xi*xi)*eta*eta*eta+((-99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi
+*xi)*eta+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+(-891.0/
+4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((81.0*xi-405.0/
+2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi
+*xi*xi)*eta*eta+(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta
+)*zeta*zeta+((-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(729.0/4.0*
+xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+3645.0/8.0*xi*
+xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 17: return (-9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi)*eta+(81.0/
+4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+81.0*xi*xi-243.0/
+4.0*xi*xi*xi)*eta*eta*eta+((99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi)*eta+(
+-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+(891.0/8.0*xi-891.0/
+2.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((-81.0/2.0*xi+162.0*xi*xi
+-243.0/2.0*xi*xi*xi)*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta
++(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((81.0/
+4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0
+/8.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*
+eta*eta)*zeta*zeta*zeta;
+      case 18: return ((9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+(-81.0/
+2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0*xi-729.0/4.0*xi*xi
++729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0
+*xi*xi*xi)*eta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(
+-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((
+27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-243.0/4.0*xi+2187.0/8.0*
+xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi
+*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 19: return ((-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(
+81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+729.0/8.0
+*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((18.0*xi-81.0*xi*xi+81.0*xi*xi*xi
+)*eta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(81.0*xi-729.0/2.0*
+xi*xi+729.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-27.0/2.0*xi+243.0/4.0*xi*xi
+-243.0/4.0*xi*xi*xi)*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*
+eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*
+zeta*zeta;
+      case 20: return ((9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi)*eta+(-81.0/
+2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0*xi-405.0/4.0*xi*xi
++243.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0
+*xi*xi*xi)*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(
+-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((
+81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-729.0/4.0*xi+3645.0/8.0*
+xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi
+*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 21: return ((-9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi)*eta+(81.0/
+4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+81.0*xi*xi-243.0/
+4.0*xi*xi*xi)*eta*eta*eta)*zeta+((81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*
+eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi
+-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-81.0/4.0*xi+
+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*
+xi*xi)*eta*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)
+*zeta*zeta*zeta;
+      case 22: return ((9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+(
+-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0
+-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-45.0/2.0
++495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta+(405.0/4.0-4455.0/8.0*xi+
+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(-405.0/4.0+4455.0/8.0*xi-3645.0/
+4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((27.0/2.0-297.0/4.0*xi+
+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi
+*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi
+-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 23: return ((-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi
+)*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+(-81.0
+/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((18.0
+-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/
+2.0*xi*xi*xi)*eta*eta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*
+eta*eta)*zeta*zeta+((-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)
+*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(
+-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*
+zeta*zeta*zeta;
+      case 24: return (9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+(
+-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0
+-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta+((-99.0/2.0+
+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta+(495.0/4.0-5445.0/8.0*xi+
+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi)*eta*eta+(-297.0/4.0+3267.0/8.0*xi-2673.0/
+4.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((81.0-891.0/2.0*xi+729.0*xi*
+xi-729.0/2.0*xi*xi*xi)*eta+(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/
+4.0*xi*xi*xi)*eta*eta+(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*
+xi*xi)*eta*eta*eta)*zeta*zeta+((-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/
+4.0*xi*xi*xi)*eta+(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi
+)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*
+eta*eta)*zeta*zeta*zeta;
+      case 25: return (-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)
+*eta+(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta*eta+(-27.0/2.0+297.0/4.0*xi
+-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta+((99.0/4.0-1089.0/8.0*xi+891.0
+/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*
+xi*xi*xi)*eta*eta+(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi
+)*eta*eta*eta)*zeta+((-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi
+)*eta+(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta*eta+(-243.0/2.0+2673.0/
+4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((81.0/4.0
+-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+(-81.0+891.0/2.0*xi-729.0
+*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi
+-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 26: return (9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+(-45.0/
+2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0*xi-243.0/4.0*xi*xi
++243.0/4.0*xi*xi*xi)*eta*eta*eta+((-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi
+*xi)*eta+(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi)*eta*eta+(-297.0/
+4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((81.0*xi-729.0/
+2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi
+*xi*xi)*eta*eta+(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta
+)*zeta*zeta+((-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(405.0/4.0*
+xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*
+xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 27: return (-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(
+18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta*eta+(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/
+4.0*xi*xi*xi)*eta*eta*eta+((99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta
++(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi)*eta*eta+(297.0/4.0*xi-2673.0/8.0
+*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((-81.0/2.0*xi+729.0/4.0*xi*xi
+-729.0/4.0*xi*xi*xi)*eta+(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta*eta+(-243.0/
+2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((81.0/4.0*
+xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*
+xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*
+eta)*zeta*zeta*zeta;
+      case 28: return ((9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+(-45.0/
+2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0*xi-243.0/4.0*xi*xi
++243.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0
+*xi*xi*xi)*eta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(
+-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((
+81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(-405.0/4.0*xi+3645.0/8.0*
+xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi
+*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 29: return ((-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(
+18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta*eta+(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/
+4.0*xi*xi*xi)*eta*eta*eta)*zeta+((81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*
+xi)*eta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi
+-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-81.0/4.0*xi+
+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*
+xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta
+)*zeta*zeta*zeta;
+      case 30: return ((9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+(
+-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0
+-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-81.0/2.0
++891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(405.0/4.0-4455.0/8.0*xi+
+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/
+4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((81.0/2.0-891.0/4.0*xi+
+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi
+*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi
+-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 31: return ((-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi
+)*eta+(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta*eta+(-27.0/2.0+297.0/4.0*xi
+-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((81.0/4.0-891.0/8.0*xi+
+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/
+2.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*
+xi*xi)*eta*eta*eta)*zeta*zeta+((-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/
+8.0*xi*xi*xi)*eta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(
+-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*
+zeta*zeta*zeta;
+      case 32: return (81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+(-891.0/2.0
+*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*eta+(729.0*xi-3645.0/2.0*xi*xi+2187.0
+/2.0*xi*xi*xi)*eta*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta
+*eta*eta)*zeta+(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi+(4455.0/4.0*
+xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi)*eta+(-3645.0/2.0*xi+18225.0/4.0*xi*
+xi-10935.0/4.0*xi*xi*xi)*eta*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*
+xi*xi*xi)*eta*eta*eta)*zeta*zeta+(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi
+*xi+(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta+(2187.0/2.0*xi
+-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*
+xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 33: return (-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+(891.0/4.0
+*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta+(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0
+*xi*xi*xi)*eta*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*
+zeta+(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi+(-4455.0/8.0*xi+4455.0/2.0*
+xi*xi-13365.0/8.0*xi*xi*xi)*eta+(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*
+xi)*eta*eta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta)
+*zeta*zeta+(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi+(2673.0/8.0*xi-2673.0/
+2.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta+(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*
+xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta
+)*zeta*zeta*zeta;
+      case 34: return (-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0
+/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*
+xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi
+*xi)*eta*eta*eta)*zeta+(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi+(-891.0*xi+4455.0/
+2.0*xi*xi-2673.0/2.0*xi*xi*xi)*eta+(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta
+*eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(
+-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+(2673.0/4.0*xi-13365.0/8.0*xi
+*xi+8019.0/8.0*xi*xi*xi)*eta+(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi
+*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)
+*zeta*zeta*zeta;
+      case 35: return (81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+(-891.0/8.0*
+xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/
+4.0*xi*xi*xi)*eta*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*
+eta*eta)*zeta+(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi+(891.0/2.0*xi-1782.0*xi*xi+
+2673.0/2.0*xi*xi*xi)*eta+(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta*eta+(
+729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(243.0/
+4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi+(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/
+8.0*xi*xi*xi)*eta+(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+(
+-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*
+zeta;
+      case 36: return ((81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+(
+-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/2.0*xi
+-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-405.0/2.0*xi+2025.0
+/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/
+8.0*xi*xi*xi)*eta*eta+(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*
+eta*eta*eta)*zeta*zeta+((243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+
+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi
+-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 37: return ((-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+(
+729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+729.0*xi*
+xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((405.0/4.0*xi-405.0*xi*xi+1215.0/4.0
+*xi*xi*xi)*eta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(
+3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((
+-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(2187.0/8.0*xi-2187.0/2.0*xi*
+xi+6561.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*
+xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 38: return ((-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+
+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+
+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((162.0*xi-405.0*xi*xi+
+243.0*xi*xi*xi)*eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(
+729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-243.0/
+2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(2187.0/4.0*xi-10935.0/8.0*xi*
+xi+6561.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi
+*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 39: return ((81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(
+-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi-729.0/
+2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((-81.0*xi+324.0*xi*xi-243.0*
+xi*xi*xi)*eta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/
+2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((243.0/4.0*xi
+-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/
+8.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*
+eta*eta)*zeta*zeta*zeta;
+      case 40: return (81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+(
+-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0*xi
+-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta+((-891.0/2.0*xi+4455.0/4.0*xi
+*xi-2673.0/4.0*xi*xi*xi)*eta+(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi
+*xi)*eta*eta+(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta*eta
+)*zeta+((729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+(-3645.0/2.0*xi+
+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta*eta+(2187.0/2.0*xi-10935.0/4.0*xi*
+xi+6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-729.0/2.0*xi+3645.0/4.0*xi*xi
+-2187.0/4.0*xi*xi*xi)*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi
+)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*
+zeta*zeta*zeta;
+      case 41: return (-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+(
+405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+243.0*xi*
+xi-729.0/4.0*xi*xi*xi)*eta*eta*eta+((891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*
+xi)*eta+(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi)*eta*eta+(2673.0/
+8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((-729.0/2.0*xi+
+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*
+xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta
+)*zeta*zeta+((729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-3645.0/8.0*xi
++3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi
++6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 42: return (-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(
+162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta*eta+(-243.0/2.0*xi+1215.0/4.0*xi*xi
+-729.0/4.0*xi*xi*xi)*eta*eta*eta+((891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*
+xi*xi)*eta+(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi)*eta*eta+(2673.0/4.0
+*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((-729.0/2.0*xi+
+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*
+xi)*eta*eta+(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta)
+*zeta*zeta+((729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-729.0*xi+
+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+
+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 43: return (81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-81.0*
+xi+324.0*xi*xi-243.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*
+xi*xi)*eta*eta*eta+((-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(
+891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi)*eta*eta+(-2673.0/8.0*xi+2673.0/
+2.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((729.0/4.0*xi-729.0*xi*xi+
+2187.0/4.0*xi*xi*xi)*eta+(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta*eta+(
+2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-729.0
+/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(729.0/2.0*xi-1458.0*xi*xi+
+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*
+xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 44: return ((81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+(
+-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0*xi
+-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-405.0/2.0*xi+3645.0
+/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+(2025.0/4.0*xi-18225.0/8.0*xi*xi+18225.0/
+8.0*xi*xi*xi)*eta*eta+(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*
+eta*eta*eta)*zeta*zeta+((243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta
++(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi
+-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 45: return ((-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+
+(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta*eta+(-243.0/2.0*xi+2187.0/4.0*xi*xi
+-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/
+8.0*xi*xi*xi)*eta+(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta*eta+(
+1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((
+-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(243.0*xi-2187.0/2.0*xi
+*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*
+xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 46: return ((-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+
+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+
+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((162.0*xi-729.0*xi*xi+
+729.0*xi*xi*xi)*eta+(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta*eta+(
+243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-243.0/
+2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(1215.0/4.0*xi-10935.0/8.0*xi*
+xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*
+xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 47: return ((81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+(
+-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*
+xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((-81.0*xi+729.0/2.0*xi*xi-729.0/
+2.0*xi*xi*xi)*eta+(324.0*xi-1458.0*xi*xi+1458.0*xi*xi*xi)*eta*eta+(-243.0*xi+
+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((243.0/4.0*xi
+-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-243.0*xi+2187.0/2.0*xi*xi-2187.0/
+2.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*
+eta*eta)*zeta*zeta*zeta;
+      case 48: return ((81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+(
+-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0*xi
+-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-729.0/2.0*xi+3645.0/
+4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0
+*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*
+eta*eta)*zeta*zeta+((729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(
+-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi
+-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 49: return ((-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+(
+405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+243.0*xi*
+xi-729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*
+xi*xi*xi)*eta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(
+2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((
+-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(3645.0/8.0*xi-3645.0/2.0*xi
+*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*
+xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 50: return ((-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+
+(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta*eta+(-243.0/2.0*xi+1215.0/4.0*xi*xi
+-729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/
+8.0*xi*xi*xi)*eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(
+2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((
+-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(729.0*xi-3645.0/2.0*xi
+*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*
+xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 51: return ((81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-81.0
+*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*
+xi*xi)*eta*eta*eta)*zeta+((-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*
+eta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+
+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((729.0/8.0*xi
+-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+1458.0*xi*xi-2187.0/
+2.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*
+eta*eta)*zeta*zeta*zeta;
+      case 52: return ((81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta
++(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta*eta+(243.0
+/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((
+-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+(2025.0/4.0
+-22275.0/8.0*xi+18225.0/4.0*xi*xi-18225.0/8.0*xi*xi*xi)*eta*eta+(-1215.0/4.0+
+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+(
+(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(-1215.0/4.0
++13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(729.0/4.0
+-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*
+zeta;
+      case 53: return ((-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*
+xi*xi)*eta+(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta*eta+(-243.0/2.0+
+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((405.0/
+4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+(-405.0+4455.0/2.0*
+xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta*eta+(1215.0/4.0-13365.0/8.0*xi+10935.0
+/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-243.0/4.0+2673.0/8.0
+*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(243.0-2673.0/2.0*xi+2187.0*xi*xi
+-2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0
+/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 54: return ((-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*
+xi*xi)*eta+(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*
+eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta
+)*zeta+((162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+(-405.0+4455.0/2.0*xi
+-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta*eta+(243.0-2673.0/2.0*xi+2187.0*xi*xi
+-2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((-243.0/2.0+2673.0/4.0*xi-2187.0/
+2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi
+-10935.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+
+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 55: return ((81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi
+*xi)*eta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0
+-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((-81.0+
+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+(324.0-1782.0*xi+2916.0*xi*xi
+-1458.0*xi*xi*xi)*eta*eta+(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*
+xi)*eta*eta*eta)*zeta*zeta+((243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/
+8.0*xi*xi*xi)*eta+(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*
+eta+(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)
+*zeta*zeta*zeta;
+      case 56: return ((729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+(
+-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta*eta+(2187.0/2.0*xi
+-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-3645.0/2.0*xi+
+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+(18225.0/4.0*xi-91125.0/8.0*xi*xi+
+54675.0/8.0*xi*xi*xi)*eta*eta+(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi
+*xi*xi)*eta*eta*eta)*zeta*zeta+((2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*
+xi*xi)*eta+(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta+(
+6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*
+zeta;
+      case 57: return ((-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+(
+3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+2187.0
+*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((3645.0/4.0*xi-3645.0*xi*xi+
+10935.0/4.0*xi*xi*xi)*eta+(-18225.0/8.0*xi+18225.0/2.0*xi*xi-54675.0/8.0*xi*xi*
+xi)*eta*eta+(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta*eta
+)*zeta*zeta+((-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+(10935.0/8.0
+*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta+(-6561.0/8.0*xi+6561.0/2.0*
+xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 58: return ((-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*
+eta+(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta*eta+(-2187.0/2.0*xi+10935.0/
+4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((3645.0/4.0*xi-18225.0/8.0*xi
+*xi+10935.0/8.0*xi*xi*xi)*eta+(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*
+xi)*eta*eta+(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta*eta
+)*zeta*zeta+((-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+(2187.0
+*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta+(-6561.0/4.0*xi+32805.0/8.0*
+xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 59: return ((729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(
+-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-2187.0*xi*xi+
+6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+((-3645.0/8.0*xi+3645.0/2.0*xi*xi
+-10935.0/8.0*xi*xi*xi)*eta+(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*
+eta*eta+(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta*eta)*
+zeta*zeta+((2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+(-2187.0/
+2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta+(6561.0/8.0*xi-6561.0/2.0*xi*
+xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 60: return ((-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*
+eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/4.0
+*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((1458.0*xi-3645.0
+*xi*xi+2187.0*xi*xi*xi)*eta+(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)
+*eta*eta+(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*
+zeta+((-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+(10935.0/4.0*
+xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta+(-6561.0/4.0*xi+32805.0/8.0*
+xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 61: return ((729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(
+-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi
+-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((-729.0*xi+2916.0*xi*
+xi-2187.0*xi*xi*xi)*eta+(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta*
+eta+(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((
+2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+(-10935.0/8.0*xi+10935.0/
+2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta+(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0
+/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 62: return ((729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*
+eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi
+-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((-729.0*xi+3645.0/
+2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+(2916.0*xi-7290.0*xi*xi+4374.0*xi*xi*xi)*eta
+*eta+(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+
+((2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+(-2187.0*xi+10935.0/
+2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta+(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0
+/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+      case 63: return ((-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*
+eta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+
+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+((729.0/2.0*xi-1458.0*
+xi*xi+2187.0/2.0*xi*xi*xi)*eta+(-1458.0*xi+5832.0*xi*xi-4374.0*xi*xi*xi)*eta*
+eta+(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta+((
+-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+(2187.0/2.0*xi-4374.0*
+xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta+(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0
+*xi*xi*xi)*eta*eta*eta)*zeta*zeta*zeta;
+    };
+  return 0;
+};
+
+
+
+template <>
+Tensor<1,3>
+FECubicSub<3>::shape_grad (const unsigned int i,
+                              const Point<3>    &p) const
+{
+  Assert (i<total_dofs, ExcInvalidIndex(i));
+
+  const double xi  = p(0),
+              eta = p(1),
+              zeta=p(2);
+                                  // originally, the return type of the
+                                  // function was Point<dim>, so we
+                                  // still construct it as that. it should
+                                  // make no difference in practice,
+                                  // however
+  switch (i)
+    {
+      case 0: return Point<3>(-11.0/2.0+18.0*xi-27.0/2.0*xi*xi+(121.0/4.0-99.0*xi+297.0/4.0*xi*xi)*eta+(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta*eta+(121.0/4.0-99.0*xi+297.0/4.0*xi*xi+(-1331.0/8.0+1089.0/2.0*xi-3267.0/8.0*xi*xi)*eta+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta*eta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta*eta*eta)*zeta+(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      -11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+(121.0/4.0-1331.0/8.0*xi+1089.0/4.0*xi*xi-1089.0/8.0*xi*xi*xi+2.0*(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta+3.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      -11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+(121.0/4.0-1331.0/8.0*xi+1089.0/4.0*xi*xi-1089.0/8.0*xi*xi*xi)*eta+(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta*eta+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 1: return Point<3>(1.0-9.0*xi+27.0/2.0*xi*xi+(-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi)*eta+(9.0-81.0*xi+243.0/2.0*xi*xi)*eta*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta*eta+(-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi+(121.0/4.0-1089.0/4.0*xi+3267.0/8.0*xi*xi)*eta+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta*eta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta*eta*eta)*zeta+(9.0-81.0*xi+243.0/2.0*xi*xi+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      -11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+(121.0/4.0*xi-1089.0/8.0*xi*xi+1089.0/8.0*xi*xi*xi+2.0*(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta+3.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      -11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+(121.0/4.0*xi-1089.0/8.0*xi*xi+1089.0/8.0*xi*xi*xi)*eta+(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta*eta+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta+(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 2: return Point<3>((1.0-9.0*xi+27.0/2.0*xi*xi+(-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi)*eta+(9.0-81.0*xi+243.0/2.0*xi*xi)*eta*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta*eta)*zeta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi+(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi)*eta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta)*zeta+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+(-11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi)*eta+(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta*eta+(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi+(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 3: return Point<3>((-11.0/2.0+18.0*xi-27.0/2.0*xi*xi+(121.0/4.0-99.0*xi+297.0/4.0*xi*xi)*eta+(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta*eta)*zeta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi+(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi)*eta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta)*zeta+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+(-11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi)*eta+(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta*eta+(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi+(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 4: return Point<3>((-11.0/2.0+18.0*xi-27.0/2.0*xi*xi)*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta+(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta*eta*eta+((121.0/4.0-99.0*xi+297.0/4.0*xi*xi)*eta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta*eta+(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+(-11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+2.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+3.0*(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta)*zeta+(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi)*eta+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta+(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 5: return Point<3>((1.0-9.0*xi+27.0/2.0*xi*xi)*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta+(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta*eta*eta+((-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi)*eta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta*eta+(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi)*eta*eta*eta)*zeta+((9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+(-11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+2.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+3.0*(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta)*zeta+(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi)*eta+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta+(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 6: return Point<3>(((1.0-9.0*xi+27.0/2.0*xi*xi)*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta+(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi)*eta+(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 7: return Point<3>(((-11.0/2.0+18.0*xi-27.0/2.0*xi*xi)*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta+(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta*eta*eta)*zeta+((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi)*eta+(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 8: return Point<3>(9.0-45.0*xi+81.0/2.0*xi*xi+(-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi)*eta+(81.0-405.0*xi+729.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+(-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi+(1089.0/4.0-5445.0/4.0*xi+9801.0/8.0*xi*xi)*eta+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta*eta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta)*zeta+(81.0-405.0*xi+729.0/2.0*xi*xi+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      -99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+(1089.0/4.0*xi-5445.0/8.0*xi*xi+3267.0/8.0*xi*xi*xi+2.0*(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*eta+3.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      -99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+(1089.0/4.0*xi-5445.0/8.0*xi*xi+3267.0/8.0*xi*xi*xi)*eta+(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*eta*eta+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*eta+(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 9: return Point<3>(-9.0/2.0+36.0*xi-81.0/2.0*xi*xi+(99.0/4.0-198.0*xi+891.0/4.0*xi*xi)*eta+(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+(99.0/4.0-198.0*xi+891.0/4.0*xi*xi+(-1089.0/8.0+1089.0*xi-9801.0/8.0*xi*xi)*eta+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta)*zeta+(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+(-1089.0/8.0*xi+1089.0/2.0*xi*xi-3267.0/8.0*xi*xi*xi+2.0*(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta+3.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta)*zeta+(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+(-1089.0/8.0*xi+1089.0/2.0*xi*xi-3267.0/8.0*xi*xi*xi)*eta+(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta*eta+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta+(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 10: return Point<3>((9.0-81.0*xi+243.0/2.0*xi*xi+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi+(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi)*eta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi+(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi)*eta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta+(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+3.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta+(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi+(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi)*eta+(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta*eta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 11: return Point<3>((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+(18.0-162.0*xi+243.0*xi*xi+(-99.0+891.0*xi-2673.0/2.0*xi*xi)*eta+(162.0-1458.0*xi+2187.0*xi*xi)*eta*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi+(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+3.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      -9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi+(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi)*eta+(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta*eta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 12: return Point<3>((9.0-45.0*xi+81.0/2.0*xi*xi+(-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi)*eta+(81.0-405.0*xi+729.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta)*zeta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi+(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta)*zeta+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+(-99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi)*eta+(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta*eta+(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 13: return Point<3>((-9.0/2.0+36.0*xi-81.0/2.0*xi*xi+(99.0/4.0-198.0*xi+891.0/4.0*xi*xi)*eta+(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta*eta)*zeta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi+(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      -9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+(99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi)*eta+(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta*eta+(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 14: return Point<3>((-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi+(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi)*eta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi+(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi)*eta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta+(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+3.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi+(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi)*eta+(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta*eta+(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi+(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 15: return Point<3>((99.0/4.0-81.0*xi+243.0/4.0*xi*xi+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+(-99.0+324.0*xi-243.0*xi*xi+(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi)*eta+(-891.0+2916.0*xi-2187.0*xi*xi)*eta*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+(297.0/4.0-243.0*xi+729.0/4.0*xi*xi+(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi)*eta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+3.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      -9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi+(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi)*eta+(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta*eta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi+(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 16: return Point<3>((9.0-45.0*xi+81.0/2.0*xi*xi)*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta+(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+((-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi)*eta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta+(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta)*zeta+((81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+(-99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+2.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+3.0*(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta)*zeta+(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi)*eta+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 17: return Point<3>((-9.0/2.0+36.0*xi-81.0/2.0*xi*xi)*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta+(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+((99.0/4.0-198.0*xi+891.0/4.0*xi*xi)*eta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta*eta+(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      -9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+(99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+2.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+3.0*(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi)*eta+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 18: return Point<3>(((9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 19: return Point<3>(((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+((18.0-162.0*xi+243.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta+(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 20: return Point<3>(((9.0-45.0*xi+81.0/2.0*xi*xi)*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta+(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi)*eta+(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 21: return Point<3>(((-9.0/2.0+36.0*xi-81.0/2.0*xi*xi)*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta+(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta*eta*eta)*zeta+((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta)*zeta+(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi)*eta+(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 22: return Point<3>(((-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+((495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta+(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 23: return Point<3>(((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-99.0+324.0*xi-243.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta+(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 24: return Point<3>((-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta*eta+(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+((1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi)*eta*eta+(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta*eta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi+2.0*(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi)*eta+3.0*(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta)*zeta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta+(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi)*eta*eta+(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 25: return Point<3>((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-99.0+324.0*xi-243.0*xi*xi)*eta*eta+(297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+((-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi)*eta*eta+(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta)*zeta+((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-891.0+2916.0*xi-2187.0*xi*xi)*eta*eta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      -9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi)*eta+3.0*(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi)*eta*eta+(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta*eta+(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 26: return Point<3>((9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta*eta+(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+((-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi)*eta*eta+(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta)*zeta+((81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta*eta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi+2.0*(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi)*eta+3.0*(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta)*zeta+(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta+(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi)*eta*eta+(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 27: return Point<3>((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(18.0-162.0*xi+243.0*xi*xi)*eta*eta+(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+((99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-99.0+891.0*xi-2673.0/2.0*xi*xi)*eta*eta+(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(162.0-1458.0*xi+2187.0*xi*xi)*eta*eta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      -9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi)*eta+3.0*(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi)*eta*eta+(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta*eta+(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 28: return Point<3>(((9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta*eta+(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta+(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 29: return Point<3>(((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(18.0-162.0*xi+243.0*xi*xi)*eta*eta+(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta)*zeta+((81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta)*zeta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta*eta+(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 30: return Point<3>(((-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta*eta+(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta*eta*eta)*zeta+((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta+(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 31: return Point<3>(((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-99.0+324.0*xi-243.0*xi*xi)*eta*eta+(297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta)*zeta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta*eta+(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 32: return Point<3>((81.0-405.0*xi+729.0/2.0*xi*xi+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi+(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi)*eta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi+(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi)*eta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+3.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi+2.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*eta+(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi+(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi)*eta+(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta+(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 33: return Point<3>((-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi+(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi)*eta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi+(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi)*eta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+3.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi+2.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      -81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta+(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi+(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi)*eta+(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta*eta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi+(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta+(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 34: return Point<3>((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+(162.0-810.0*xi+729.0*xi*xi+(-891.0+4455.0*xi-8019.0/2.0*xi*xi)*eta+(1458.0-7290.0*xi+6561.0*xi*xi)*eta*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi+(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi)*eta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+3.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi+2.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      -81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi+(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi)*eta+(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta*eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta+(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 35: return Point<3>((81.0/4.0-162.0*xi+729.0/4.0*xi*xi+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+(-81.0+648.0*xi-729.0*xi*xi+(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi)*eta+(-729.0+5832.0*xi-6561.0*xi*xi)*eta*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi+(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi)*eta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+3.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi+2.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi+(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi)*eta+(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta*eta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi+(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta+(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 36: return Point<3>(((81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 37: return Point<3>(((-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+((405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 38: return Point<3>(((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+((162.0-810.0*xi+729.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 39: return Point<3>(((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-81.0+648.0*xi-729.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 40: return Point<3>((81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta*eta+(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+((-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi)*eta*eta+(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi)*eta*eta*eta)*zeta+((729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta*eta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi+2.0*(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi)*eta+3.0*(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta)*zeta+(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*eta+(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi)*eta*eta+(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta*eta+(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 41: return Point<3>((-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta*eta+(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+((891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta*eta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      -81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi+2.0*(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi)*eta+3.0*(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta+(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi)*eta*eta+(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 42: return Point<3>((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(162.0-810.0*xi+729.0*xi*xi)*eta*eta+(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+((891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-891.0+4455.0*xi-8019.0/2.0*xi*xi)*eta*eta+(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(1458.0-7290.0*xi+6561.0*xi*xi)*eta*eta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      -81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi)*eta+3.0*(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+3.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi)*eta*eta+(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta*eta+(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 43: return Point<3>((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-81.0+648.0*xi-729.0*xi*xi)*eta*eta+(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+((-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi)*eta*eta*eta)*zeta+((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-729.0+5832.0*xi-6561.0*xi*xi)*eta*eta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi)*eta+3.0*(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta)*zeta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi)*eta*eta+(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 44: return Point<3>(((81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta*eta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta+(2025.0/4.0-18225.0/4.0*xi+54675.0/8.0*xi*xi)*eta*eta+(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta+(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta+(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi+2.0*(2025.0/4.0*xi-18225.0/8.0*xi*xi+18225.0/8.0*xi*xi*xi)*eta+3.0*(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+(2025.0/4.0*xi-18225.0/8.0*xi*xi+18225.0/8.0*xi*xi*xi)*eta*eta+(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 45: return Point<3>(((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(162.0-1458.0*xi+2187.0*xi*xi)*eta*eta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+((405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta*eta+(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta+(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi+2.0*(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta+3.0*(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta*eta+(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta*eta+(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 46: return Point<3>(((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+((162.0-1458.0*xi+2187.0*xi*xi)*eta+(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta*eta+(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi+2.0*(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta+3.0*(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta*eta+(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 47: return Point<3>(((81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+(324.0-2916.0*xi+4374.0*xi*xi)*eta*eta+(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi+2.0*(324.0*xi-1458.0*xi*xi+1458.0*xi*xi*xi)*eta+3.0*(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+(324.0*xi-1458.0*xi*xi+1458.0*xi*xi*xi)*eta*eta+(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 48: return Point<3>(((81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta*eta+(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 49: return Point<3>(((-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta*eta+(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 50: return Point<3>(((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(162.0-810.0*xi+729.0*xi*xi)*eta*eta+(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+((729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta*eta+(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 51: return Point<3>(((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-81.0+648.0*xi-729.0*xi*xi)*eta*eta+(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 52: return Point<3>(((-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta*eta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+((4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta+(-22275.0/8.0+18225.0/2.0*xi-54675.0/8.0*xi*xi)*eta*eta+(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta+(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi+2.0*(2025.0/4.0-22275.0/8.0*xi+18225.0/4.0*xi*xi-18225.0/8.0*xi*xi*xi)*eta+3.0*(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+(2025.0/4.0-22275.0/8.0*xi+18225.0/4.0*xi*xi-18225.0/8.0*xi*xi*xi)*eta*eta+(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 53: return Point<3>(((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-891.0+2916.0*xi-2187.0*xi*xi)*eta*eta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta*eta+(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta+(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta*eta+(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi+2.0*(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta+3.0*(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta*eta+(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta*eta+(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 54: return Point<3>(((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-891.0+2916.0*xi-2187.0*xi*xi)*eta+(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta*eta+(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta+(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta*eta+(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi+2.0*(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta+3.0*(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta*eta+(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 55: return Point<3>(((-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+((891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+(-1782.0+5832.0*xi-4374.0*xi*xi)*eta*eta+(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta+(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi+2.0*(324.0-1782.0*xi+2916.0*xi*xi-1458.0*xi*xi*xi)*eta+3.0*(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+(324.0-1782.0*xi+2916.0*xi*xi-1458.0*xi*xi*xi)*eta*eta+(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 56: return Point<3>(((729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta*eta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta+(18225.0/4.0-91125.0/4.0*xi+164025.0/8.0*xi*xi)*eta*eta+(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta+(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta*eta+(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi+2.0*(18225.0/4.0*xi-91125.0/8.0*xi*xi+54675.0/8.0*xi*xi*xi)*eta+3.0*(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi+2.0*(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta+3.0*(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta*eta+(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+(18225.0/4.0*xi-91125.0/8.0*xi*xi+54675.0/8.0*xi*xi*xi)*eta*eta+(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta+(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 57: return Point<3>(((-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta*eta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+((3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta+(-18225.0/8.0+18225.0*xi-164025.0/8.0*xi*xi)*eta*eta+(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta+(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta*eta+(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi+2.0*(-18225.0/8.0*xi+18225.0/2.0*xi*xi-54675.0/8.0*xi*xi*xi)*eta+3.0*(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi+2.0*(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta+3.0*(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+(-18225.0/8.0*xi+18225.0/2.0*xi*xi-54675.0/8.0*xi*xi*xi)*eta*eta+(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta+(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 58: return Point<3>(((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(1458.0-7290.0*xi+6561.0*xi*xi)*eta*eta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+((3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta*eta+(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta+(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta*eta+(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+3.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi+2.0*(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta+3.0*(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi+2.0*(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta+3.0*(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta*eta+(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta*eta+(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta+(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 59: return Point<3>(((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-729.0+5832.0*xi-6561.0*xi*xi)*eta*eta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+((-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta*eta+(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta+((2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta+(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta*eta+(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi+2.0*(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta+3.0*(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi+2.0*(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta+3.0*(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta*eta+2.0*((-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta*eta+(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta+(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 60: return Point<3>(((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+((1458.0-7290.0*xi+6561.0*xi*xi)*eta+(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta*eta+(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta+(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta*eta+(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi+2.0*(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta+3.0*(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi+2.0*(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta+3.0*(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta*eta+(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta+(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 61: return Point<3>(((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-729.0+5832.0*xi-6561.0*xi*xi)*eta+(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta*eta+(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta+(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta*eta+(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi+2.0*(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi+2.0*(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta+3.0*(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta+(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 62: return Point<3>(((729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+((-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+(2916.0-14580.0*xi+13122.0*xi*xi)*eta*eta+(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta+(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta*eta+(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi+2.0*(2916.0*xi-7290.0*xi*xi+4374.0*xi*xi*xi)*eta+3.0*(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi+2.0*(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta+3.0*(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+(2916.0*xi-7290.0*xi*xi+4374.0*xi*xi*xi)*eta*eta+(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta+(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+      case 63: return Point<3>(((-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+((729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+(-1458.0+11664.0*xi-13122.0*xi*xi)*eta*eta+(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta*eta*eta)*zeta*zeta+((-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta+(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta*eta+(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta*zeta,
+      (-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi+2.0*(-1458.0*xi+5832.0*xi*xi-4374.0*xi*xi*xi)*eta+3.0*(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi+2.0*(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta+3.0*(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta*zeta,
+      (-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta+2.0*((729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+(-1458.0*xi+5832.0*xi*xi-4374.0*xi*xi*xi)*eta*eta+(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta+(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta*zeta);
+    };
+  return Point<3> ();
+};
+
+
+
+template <>
+Tensor<2,3>
+FECubicSub<3>::shape_grad_grad (const unsigned int i,
+                               const Point<3>    &p) const
+{
+  Assert (i<total_dofs, ExcInvalidIndex(i));
+
+  const double xi  = p(0),
+              eta = p(1),
+              zeta=p(2);
+  Tensor<2,3> return_value;
+  
+  switch (i)
+    {
+case 0:
+return_value[0][0] = 18.0-27.0*xi+(-99.0+297.0/2.0*xi)*eta+(162.0-243.0*xi)*eta*eta+(-81.0+243.0/2.0*xi)*eta*eta*eta+(-99.0+297.0/2.0*xi+(1089.0/2.0-3267.0/4.0*xi)*eta+(-891.0+2673.0/2.0*xi)*eta*eta+(891.0/2.0-2673.0/4.0*xi)*eta*eta*eta)*zeta+(162.0-243.0*xi+(-891.0+2673.0/2.0*xi)*eta+(1458.0-2187.0*xi)*eta*eta+(-729.0+2187.0/2.0*xi)*eta*eta*eta)*zeta*zeta+(-81.0+243.0/2.0*xi+(891.0/2.0-2673.0/4.0*xi)*eta+(-729.0+2187.0/2.0*xi)*eta*eta+(729.0/2.0-2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = 121.0/4.0-99.0*xi+297.0/4.0*xi*xi+2.0*(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+3.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta+(-1331.0/8.0+1089.0/2.0*xi-3267.0/8.0*xi*xi+2.0*(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+3.0*(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta*eta)*zeta+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi+2.0*(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = 121.0/4.0-99.0*xi+297.0/4.0*xi*xi+(-1331.0/8.0+1089.0/2.0*xi-3267.0/8.0*xi*xi)*eta+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta*eta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta*eta*eta+2.0*(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = 121.0/4.0-99.0*xi+297.0/4.0*xi*xi+2.0*(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+3.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta+(-1331.0/8.0+1089.0/2.0*xi-3267.0/8.0*xi*xi+2.0*(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+3.0*(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta*eta)*zeta+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi+2.0*(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = 18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi+6.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi+6.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta)*zeta+(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi+6.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi+6.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 121.0/4.0-1331.0/8.0*xi+1089.0/4.0*xi*xi-1089.0/8.0*xi*xi*xi+2.0*(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta+3.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta+2.0*(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = 121.0/4.0-99.0*xi+297.0/4.0*xi*xi+(-1331.0/8.0+1089.0/2.0*xi-3267.0/8.0*xi*xi)*eta+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta*eta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta*eta*eta+2.0*(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 121.0/4.0-1331.0/8.0*xi+1089.0/4.0*xi*xi-1089.0/8.0*xi*xi*xi+2.0*(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta+3.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta+2.0*(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi+2.0*(-99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi)*eta+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+break;
+case 1:
+return_value[0][0] = -9.0+27.0*xi+(99.0/2.0-297.0/2.0*xi)*eta+(-81.0+243.0*xi)*eta*eta+(81.0/2.0-243.0/2.0*xi)*eta*eta*eta+(99.0/2.0-297.0/2.0*xi+(-1089.0/4.0+3267.0/4.0*xi)*eta+(891.0/2.0-2673.0/2.0*xi)*eta*eta+(-891.0/4.0+2673.0/4.0*xi)*eta*eta*eta)*zeta+(-81.0+243.0*xi+(891.0/2.0-2673.0/2.0*xi)*eta+(-729.0+2187.0*xi)*eta*eta+(729.0/2.0-2187.0/2.0*xi)*eta*eta*eta)*zeta*zeta+(81.0/2.0-243.0/2.0*xi+(-891.0/4.0+2673.0/4.0*xi)*eta+(729.0/2.0-2187.0/2.0*xi)*eta*eta+(-729.0/4.0+2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = -11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi+2.0*(9.0-81.0*xi+243.0/2.0*xi*xi)*eta+3.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta+(121.0/4.0-1089.0/4.0*xi+3267.0/8.0*xi*xi+2.0*(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+3.0*(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta*eta)*zeta+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi+2.0*(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = -11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi+(121.0/4.0-1089.0/4.0*xi+3267.0/8.0*xi*xi)*eta+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta*eta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta*eta*eta+2.0*(9.0-81.0*xi+243.0/2.0*xi*xi+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = -11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi+2.0*(9.0-81.0*xi+243.0/2.0*xi*xi)*eta+3.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta+(121.0/4.0-1089.0/4.0*xi+3267.0/8.0*xi*xi+2.0*(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+3.0*(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta*eta)*zeta+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi+2.0*(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = 18.0*xi-81.0*xi*xi+81.0*xi*xi*xi+6.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi+6.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta)*zeta+(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi+6.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi+6.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 121.0/4.0*xi-1089.0/8.0*xi*xi+1089.0/8.0*xi*xi*xi+2.0*(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta+3.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta+2.0*(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = -11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi+(121.0/4.0-1089.0/4.0*xi+3267.0/8.0*xi*xi)*eta+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta*eta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta*eta*eta+2.0*(9.0-81.0*xi+243.0/2.0*xi*xi+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 121.0/4.0*xi-1089.0/8.0*xi*xi+1089.0/8.0*xi*xi*xi+2.0*(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta+3.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta+2.0*(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 18.0*xi-81.0*xi*xi+81.0*xi*xi*xi+2.0*(-99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi)*eta+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+break;
+case 2:
+return_value[0][0] = (-9.0+27.0*xi+(99.0/2.0-297.0/2.0*xi)*eta+(-81.0+243.0*xi)*eta*eta+(81.0/2.0-243.0/2.0*xi)*eta*eta*eta)*zeta+(81.0/2.0-243.0/2.0*xi+(-891.0/4.0+2673.0/4.0*xi)*eta+(729.0/2.0-2187.0/2.0*xi)*eta*eta+(-729.0/4.0+2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta+(-81.0/2.0+243.0/2.0*xi+(891.0/4.0-2673.0/4.0*xi)*eta+(-729.0/2.0+2187.0/2.0*xi)*eta*eta+(729.0/4.0-2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi+2.0*(9.0-81.0*xi+243.0/2.0*xi*xi)*eta+3.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta)*zeta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi+2.0*(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = 1.0-9.0*xi+27.0/2.0*xi*xi+(-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi)*eta+(9.0-81.0*xi+243.0/2.0*xi*xi)*eta*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta*eta+2.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi+(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi)*eta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi+2.0*(9.0-81.0*xi+243.0/2.0*xi*xi)*eta+3.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta)*zeta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi+2.0*(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (18.0*xi-81.0*xi*xi+81.0*xi*xi*xi+6.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta)*zeta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi+6.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi+6.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+2.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = 1.0-9.0*xi+27.0/2.0*xi*xi+(-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi)*eta+(9.0-81.0*xi+243.0/2.0*xi*xi)*eta*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta*eta+2.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi+(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi)*eta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+2.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = -9.0*xi+81.0/2.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi+(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+break;
+case 3:
+return_value[0][0] = (18.0-27.0*xi+(-99.0+297.0/2.0*xi)*eta+(162.0-243.0*xi)*eta*eta+(-81.0+243.0/2.0*xi)*eta*eta*eta)*zeta+(-81.0+243.0/2.0*xi+(891.0/2.0-2673.0/4.0*xi)*eta+(-729.0+2187.0/2.0*xi)*eta*eta+(729.0/2.0-2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta+(81.0-243.0/2.0*xi+(-891.0/2.0+2673.0/4.0*xi)*eta+(729.0-2187.0/2.0*xi)*eta*eta+(-729.0/2.0+2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (121.0/4.0-99.0*xi+297.0/4.0*xi*xi+2.0*(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+3.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta)*zeta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi+2.0*(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = -11.0/2.0+18.0*xi-27.0/2.0*xi*xi+(121.0/4.0-99.0*xi+297.0/4.0*xi*xi)*eta+(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta*eta+2.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi+(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi)*eta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (121.0/4.0-99.0*xi+297.0/4.0*xi*xi+2.0*(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+3.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta)*zeta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi+2.0*(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi+6.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta)*zeta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi+6.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi+6.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+2.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = -11.0/2.0+18.0*xi-27.0/2.0*xi*xi+(121.0/4.0-99.0*xi+297.0/4.0*xi*xi)*eta+(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta*eta+2.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi+(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi)*eta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+2.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = -9.0+99.0/2.0*xi-81.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi+(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+break;
+case 4:
+return_value[0][0] = (18.0-27.0*xi)*eta+(-81.0+243.0/2.0*xi)*eta*eta+(81.0-243.0/2.0*xi)*eta*eta*eta+((-99.0+297.0/2.0*xi)*eta+(891.0/2.0-2673.0/4.0*xi)*eta*eta+(-891.0/2.0+2673.0/4.0*xi)*eta*eta*eta)*zeta+((162.0-243.0*xi)*eta+(-729.0+2187.0/2.0*xi)*eta*eta+(729.0-2187.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((-81.0+243.0/2.0*xi)*eta+(729.0/2.0-2187.0/4.0*xi)*eta*eta+(-729.0/2.0+2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = -11.0/2.0+18.0*xi-27.0/2.0*xi*xi+2.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+3.0*(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta*eta+(121.0/4.0-99.0*xi+297.0/4.0*xi*xi+2.0*(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+3.0*(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi)*eta*eta)*zeta+(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+3.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (121.0/4.0-99.0*xi+297.0/4.0*xi*xi)*eta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta*eta+(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi)*eta*eta*eta+2.0*((-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = -11.0/2.0+18.0*xi-27.0/2.0*xi*xi+2.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+3.0*(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta*eta+(121.0/4.0-99.0*xi+297.0/4.0*xi*xi+2.0*(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+3.0*(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi)*eta*eta)*zeta+(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+3.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = -9.0+99.0/2.0*xi-81.0*xi*xi+81.0/2.0*xi*xi*xi+6.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(99.0/2.0-1089.0/4.0*xi+891.0/2.0*xi*xi-891.0/4.0*xi*xi*xi+6.0*(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi)*eta)*zeta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi+6.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi+6.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+2.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+3.0*(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta+2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (121.0/4.0-99.0*xi+297.0/4.0*xi*xi)*eta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta*eta+(1089.0/8.0-891.0/2.0*xi+2673.0/8.0*xi*xi)*eta*eta*eta+2.0*((-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+2.0*(99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi)*eta+3.0*(-99.0/4.0+1089.0/8.0*xi-891.0/4.0*xi*xi+891.0/8.0*xi*xi*xi)*eta*eta+2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+break;
+case 5:
+return_value[0][0] = (-9.0+27.0*xi)*eta+(81.0/2.0-243.0/2.0*xi)*eta*eta+(-81.0/2.0+243.0/2.0*xi)*eta*eta*eta+((99.0/2.0-297.0/2.0*xi)*eta+(-891.0/4.0+2673.0/4.0*xi)*eta*eta+(891.0/4.0-2673.0/4.0*xi)*eta*eta*eta)*zeta+((-81.0+243.0*xi)*eta+(729.0/2.0-2187.0/2.0*xi)*eta*eta+(-729.0/2.0+2187.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((81.0/2.0-243.0/2.0*xi)*eta+(-729.0/4.0+2187.0/4.0*xi)*eta*eta+(729.0/4.0-2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = 1.0-9.0*xi+27.0/2.0*xi*xi+2.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+3.0*(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta*eta+(-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi+2.0*(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+3.0*(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi)*eta*eta)*zeta+(9.0-81.0*xi+243.0/2.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+3.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi)*eta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta*eta+(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi)*eta*eta*eta+2.0*((9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = 1.0-9.0*xi+27.0/2.0*xi*xi+2.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+3.0*(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta*eta+(-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi+2.0*(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+3.0*(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi)*eta*eta)*zeta+(9.0-81.0*xi+243.0/2.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+3.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = -9.0*xi+81.0/2.0*xi*xi-81.0/2.0*xi*xi*xi+6.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(99.0/2.0*xi-891.0/4.0*xi*xi+891.0/4.0*xi*xi*xi+6.0*(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi)*eta)*zeta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi+6.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+6.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+2.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+3.0*(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta+2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi)*eta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta*eta+(-99.0/4.0+891.0/4.0*xi-2673.0/8.0*xi*xi)*eta*eta*eta+2.0*((9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+2.0*(99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi)*eta+3.0*(-99.0/4.0*xi+891.0/8.0*xi*xi-891.0/8.0*xi*xi*xi)*eta*eta+2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+break;
+case 6:
+return_value[0][0] = ((-9.0+27.0*xi)*eta+(81.0/2.0-243.0/2.0*xi)*eta*eta+(-81.0/2.0+243.0/2.0*xi)*eta*eta*eta)*zeta+((81.0/2.0-243.0/2.0*xi)*eta+(-729.0/4.0+2187.0/4.0*xi)*eta*eta+(729.0/4.0-2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-81.0/2.0+243.0/2.0*xi)*eta+(729.0/4.0-2187.0/4.0*xi)*eta*eta+(-729.0/4.0+2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (1.0-9.0*xi+27.0/2.0*xi*xi+2.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+3.0*(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta*eta)*zeta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+3.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi+2.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta+3.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (1.0-9.0*xi+27.0/2.0*xi*xi)*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta+(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta*eta*eta+2.0*((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (1.0-9.0*xi+27.0/2.0*xi*xi+2.0*(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+3.0*(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta*eta)*zeta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+3.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi+2.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta+3.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-9.0*xi+81.0/2.0*xi*xi-81.0/2.0*xi*xi*xi+6.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta)*zeta+(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+6.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+6.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (1.0-9.0*xi+27.0/2.0*xi*xi)*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta+(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta*eta*eta+2.0*((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+break;
+case 7:
+return_value[0][0] = ((18.0-27.0*xi)*eta+(-81.0+243.0/2.0*xi)*eta*eta+(81.0-243.0/2.0*xi)*eta*eta*eta)*zeta+((-81.0+243.0/2.0*xi)*eta+(729.0/2.0-2187.0/4.0*xi)*eta*eta+(-729.0/2.0+2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((81.0-243.0/2.0*xi)*eta+(-729.0/2.0+2187.0/4.0*xi)*eta*eta+(729.0/2.0-2187.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-11.0/2.0+18.0*xi-27.0/2.0*xi*xi+2.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+3.0*(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta*eta)*zeta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+3.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi+2.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta+3.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-11.0/2.0+18.0*xi-27.0/2.0*xi*xi)*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta+(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta*eta*eta+2.0*((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-11.0/2.0+18.0*xi-27.0/2.0*xi*xi+2.0*(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+3.0*(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta*eta)*zeta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+3.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi+2.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta+3.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-9.0+99.0/2.0*xi-81.0*xi*xi+81.0/2.0*xi*xi*xi+6.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta)*zeta+(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi+6.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+6.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-11.0/2.0+18.0*xi-27.0/2.0*xi*xi)*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta+(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta*eta*eta+2.0*((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+break;
+case 8:
+return_value[0][0] = -45.0+81.0*xi+(495.0/2.0-891.0/2.0*xi)*eta+(-405.0+729.0*xi)*eta*eta+(405.0/2.0-729.0/2.0*xi)*eta*eta*eta+(495.0/2.0-891.0/2.0*xi+(-5445.0/4.0+9801.0/4.0*xi)*eta+(4455.0/2.0-8019.0/2.0*xi)*eta*eta+(-4455.0/4.0+8019.0/4.0*xi)*eta*eta*eta)*zeta+(-405.0+729.0*xi+(4455.0/2.0-8019.0/2.0*xi)*eta+(-3645.0+6561.0*xi)*eta*eta+(3645.0/2.0-6561.0/2.0*xi)*eta*eta*eta)*zeta*zeta+(405.0/2.0-729.0/2.0*xi+(-4455.0/4.0+8019.0/4.0*xi)*eta+(3645.0/2.0-6561.0/2.0*xi)*eta*eta+(-3645.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = -99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi+2.0*(81.0-405.0*xi+729.0/2.0*xi*xi)*eta+3.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta+(1089.0/4.0-5445.0/4.0*xi+9801.0/8.0*xi*xi+2.0*(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+3.0*(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta)*zeta+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi+2.0*(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = -99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi+(1089.0/4.0-5445.0/4.0*xi+9801.0/8.0*xi*xi)*eta+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta*eta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta+2.0*(81.0-405.0*xi+729.0/2.0*xi*xi+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = -99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi+2.0*(81.0-405.0*xi+729.0/2.0*xi*xi)*eta+3.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta+(1089.0/4.0-5445.0/4.0*xi+9801.0/8.0*xi*xi+2.0*(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+3.0*(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta)*zeta+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi+2.0*(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = 162.0*xi-405.0*xi*xi+243.0*xi*xi*xi+6.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi+6.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta)*zeta+(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi+6.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi+6.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 1089.0/4.0*xi-5445.0/8.0*xi*xi+3267.0/8.0*xi*xi*xi+2.0*(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*eta+3.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = -99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi+(1089.0/4.0-5445.0/4.0*xi+9801.0/8.0*xi*xi)*eta+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta*eta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta+2.0*(81.0-405.0*xi+729.0/2.0*xi*xi+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 1089.0/4.0*xi-5445.0/8.0*xi*xi+3267.0/8.0*xi*xi*xi+2.0*(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*eta+3.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 162.0*xi-405.0*xi*xi+243.0*xi*xi*xi+2.0*(-891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi)*eta+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+break;
+case 9:
+return_value[0][0] = 36.0-81.0*xi+(-198.0+891.0/2.0*xi)*eta+(324.0-729.0*xi)*eta*eta+(-162.0+729.0/2.0*xi)*eta*eta*eta+(-198.0+891.0/2.0*xi+(1089.0-9801.0/4.0*xi)*eta+(-1782.0+8019.0/2.0*xi)*eta*eta+(891.0-8019.0/4.0*xi)*eta*eta*eta)*zeta+(324.0-729.0*xi+(-1782.0+8019.0/2.0*xi)*eta+(2916.0-6561.0*xi)*eta*eta+(-1458.0+6561.0/2.0*xi)*eta*eta*eta)*zeta*zeta+(-162.0+729.0/2.0*xi+(891.0-8019.0/4.0*xi)*eta+(-1458.0+6561.0/2.0*xi)*eta*eta+(729.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = 99.0/4.0-198.0*xi+891.0/4.0*xi*xi+2.0*(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+3.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta+(-1089.0/8.0+1089.0*xi-9801.0/8.0*xi*xi+2.0*(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+3.0*(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta*eta)*zeta+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi+2.0*(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = 99.0/4.0-198.0*xi+891.0/4.0*xi*xi+(-1089.0/8.0+1089.0*xi-9801.0/8.0*xi*xi)*eta+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta+2.0*(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = 99.0/4.0-198.0*xi+891.0/4.0*xi*xi+2.0*(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+3.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta+(-1089.0/8.0+1089.0*xi-9801.0/8.0*xi*xi+2.0*(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+3.0*(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta*eta)*zeta+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi+2.0*(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = -81.0*xi+324.0*xi*xi-243.0*xi*xi*xi+6.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi+6.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta)*zeta+(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi+6.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi+6.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -1089.0/8.0*xi+1089.0/2.0*xi*xi-3267.0/8.0*xi*xi*xi+2.0*(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta+3.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = 99.0/4.0-198.0*xi+891.0/4.0*xi*xi+(-1089.0/8.0+1089.0*xi-9801.0/8.0*xi*xi)*eta+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta+2.0*(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -1089.0/8.0*xi+1089.0/2.0*xi*xi-3267.0/8.0*xi*xi*xi+2.0*(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta+3.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = -81.0*xi+324.0*xi*xi-243.0*xi*xi*xi+2.0*(891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi)*eta+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-81.0+243.0*xi+(891.0/2.0-2673.0/2.0*xi)*eta+(-729.0+2187.0*xi)*eta*eta+(729.0/2.0-2187.0/2.0*xi)*eta*eta*eta)*zeta+(405.0/2.0-1215.0/2.0*xi+(-4455.0/4.0+13365.0/4.0*xi)*eta+(3645.0/2.0-10935.0/2.0*xi)*eta*eta+(-3645.0/4.0+10935.0/4.0*xi)*eta*eta*eta)*zeta*zeta+(-243.0/2.0+729.0/2.0*xi+(2673.0/4.0-8019.0/4.0*xi)*eta+(-2187.0/2.0+6561.0/2.0*xi)*eta*eta+(2187.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi+2.0*(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta+(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi+2.0*(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta+3.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi+2.0*(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = 9.0-81.0*xi+243.0/2.0*xi*xi+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+2.0*(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi+(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi)*eta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi+(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi)*eta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi+2.0*(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta+(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi+2.0*(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta+3.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi+2.0*(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (162.0*xi-729.0*xi*xi+729.0*xi*xi*xi+6.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta)*zeta+(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi+6.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi+6.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+3.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = 9.0-81.0*xi+243.0/2.0*xi*xi+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+2.0*(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi+(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi)*eta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi+(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi)*eta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+3.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = -45.0*xi+405.0/2.0*xi*xi-405.0/2.0*xi*xi*xi+2.0*(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi)*eta+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta*eta+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (81.0/2.0-243.0/2.0*xi+(-891.0/4.0+2673.0/4.0*xi)*eta+(729.0/2.0-2187.0/2.0*xi)*eta*eta+(-729.0/4.0+2187.0/4.0*xi)*eta*eta*eta)*zeta+(-162.0+486.0*xi+(891.0-2673.0*xi)*eta+(-1458.0+4374.0*xi)*eta*eta+(729.0-2187.0*xi)*eta*eta*eta)*zeta*zeta+(243.0/2.0-729.0/2.0*xi+(-2673.0/4.0+8019.0/4.0*xi)*eta+(2187.0/2.0-6561.0/2.0*xi)*eta*eta+(-2187.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta+(-99.0+891.0*xi-2673.0/2.0*xi*xi+2.0*(162.0-1458.0*xi+2187.0*xi*xi)*eta+3.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = -9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta+2.0*(18.0-162.0*xi+243.0*xi*xi+(-99.0+891.0*xi-2673.0/2.0*xi*xi)*eta+(162.0-1458.0*xi+2187.0*xi*xi)*eta*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi+(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta+(-99.0+891.0*xi-2673.0/2.0*xi*xi+2.0*(162.0-1458.0*xi+2187.0*xi*xi)*eta+3.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi+6.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta)*zeta+(324.0*xi-1458.0*xi*xi+1458.0*xi*xi*xi+6.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi+6.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+2.0*(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+3.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = -9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta+2.0*(18.0-162.0*xi+243.0*xi*xi+(-99.0+891.0*xi-2673.0/2.0*xi*xi)*eta+(162.0-1458.0*xi+2187.0*xi*xi)*eta*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi+(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+2.0*(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+3.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 36.0*xi-162.0*xi*xi+162.0*xi*xi*xi+2.0*(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi)*eta+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta*eta+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-45.0+81.0*xi+(495.0/2.0-891.0/2.0*xi)*eta+(-405.0+729.0*xi)*eta*eta+(405.0/2.0-729.0/2.0*xi)*eta*eta*eta)*zeta+(405.0/2.0-729.0/2.0*xi+(-4455.0/4.0+8019.0/4.0*xi)*eta+(3645.0/2.0-6561.0/2.0*xi)*eta*eta+(-3645.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta+(-405.0/2.0+729.0/2.0*xi+(4455.0/4.0-8019.0/4.0*xi)*eta+(-3645.0/2.0+6561.0/2.0*xi)*eta*eta+(3645.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi+2.0*(81.0-405.0*xi+729.0/2.0*xi*xi)*eta+3.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta)*zeta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi+2.0*(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = 9.0-45.0*xi+81.0/2.0*xi*xi+(-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi)*eta+(81.0-405.0*xi+729.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+2.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi+(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi+2.0*(81.0-405.0*xi+729.0/2.0*xi*xi)*eta+3.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta)*zeta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi+2.0*(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (162.0*xi-405.0*xi*xi+243.0*xi*xi*xi+6.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta)*zeta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi+6.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi+6.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+2.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = 9.0-45.0*xi+81.0/2.0*xi*xi+(-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi)*eta+(81.0-405.0*xi+729.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+2.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi+(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+2.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = -81.0*xi+405.0/2.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (36.0-81.0*xi+(-198.0+891.0/2.0*xi)*eta+(324.0-729.0*xi)*eta*eta+(-162.0+729.0/2.0*xi)*eta*eta*eta)*zeta+(-162.0+729.0/2.0*xi+(891.0-8019.0/4.0*xi)*eta+(-1458.0+6561.0/2.0*xi)*eta*eta+(729.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta+(162.0-729.0/2.0*xi+(-891.0+8019.0/4.0*xi)*eta+(1458.0-6561.0/2.0*xi)*eta*eta+(-729.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (99.0/4.0-198.0*xi+891.0/4.0*xi*xi+2.0*(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+3.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta)*zeta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi+2.0*(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = -9.0/2.0+36.0*xi-81.0/2.0*xi*xi+(99.0/4.0-198.0*xi+891.0/4.0*xi*xi)*eta+(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+2.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi+(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (99.0/4.0-198.0*xi+891.0/4.0*xi*xi+2.0*(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+3.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta)*zeta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi+2.0*(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi+6.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta)*zeta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi+6.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi+6.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+2.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = -9.0/2.0+36.0*xi-81.0/2.0*xi*xi+(99.0/4.0-198.0*xi+891.0/4.0*xi*xi)*eta+(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+2.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi+(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+2.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 81.0/2.0*xi-162.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi+(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (162.0-243.0*xi+(-891.0+2673.0/2.0*xi)*eta+(1458.0-2187.0*xi)*eta*eta+(-729.0+2187.0/2.0*xi)*eta*eta*eta)*zeta+(-405.0+1215.0/2.0*xi+(4455.0/2.0-13365.0/4.0*xi)*eta+(-3645.0+10935.0/2.0*xi)*eta*eta+(3645.0/2.0-10935.0/4.0*xi)*eta*eta*eta)*zeta*zeta+(243.0-729.0/2.0*xi+(-2673.0/2.0+8019.0/4.0*xi)*eta+(2187.0-6561.0/2.0*xi)*eta*eta+(-2187.0/2.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi+2.0*(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta+(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi+2.0*(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta+3.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi+2.0*(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = -99.0/2.0+162.0*xi-243.0/2.0*xi*xi+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+2.0*(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi+(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi)*eta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi+(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi)*eta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi+2.0*(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta+(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi+2.0*(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta+3.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi+2.0*(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi+6.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta)*zeta+(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi+6.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi+6.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+3.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = -99.0/2.0+162.0*xi-243.0/2.0*xi*xi+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+2.0*(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi+(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi)*eta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi+(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi)*eta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+3.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = -45.0+495.0/2.0*xi-405.0*xi*xi+405.0/2.0*xi*xi*xi+2.0*(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi)*eta+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta*eta+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi+(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-81.0+243.0/2.0*xi+(891.0/2.0-2673.0/4.0*xi)*eta+(-729.0+2187.0/2.0*xi)*eta*eta+(729.0/2.0-2187.0/4.0*xi)*eta*eta*eta)*zeta+(324.0-486.0*xi+(-1782.0+2673.0*xi)*eta+(2916.0-4374.0*xi)*eta*eta+(-1458.0+2187.0*xi)*eta*eta*eta)*zeta*zeta+(-243.0+729.0/2.0*xi+(2673.0/2.0-8019.0/4.0*xi)*eta+(-2187.0+6561.0/2.0*xi)*eta*eta+(2187.0/2.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta+(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi+2.0*(-891.0+2916.0*xi-2187.0*xi*xi)*eta+3.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi+2.0*(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = 99.0/4.0-81.0*xi+243.0/4.0*xi*xi+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta+2.0*(-99.0+324.0*xi-243.0*xi*xi+(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi)*eta+(-891.0+2916.0*xi-2187.0*xi*xi)*eta*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*(297.0/4.0-243.0*xi+729.0/4.0*xi*xi+(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi)*eta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta+(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi+2.0*(-891.0+2916.0*xi-2187.0*xi*xi)*eta+3.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi+2.0*(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi+6.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta)*zeta+(324.0-1782.0*xi+2916.0*xi*xi-1458.0*xi*xi*xi+6.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi+6.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+2.0*(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+3.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = 99.0/4.0-81.0*xi+243.0/4.0*xi*xi+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta+2.0*(-99.0+324.0*xi-243.0*xi*xi+(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi)*eta+(-891.0+2916.0*xi-2187.0*xi*xi)*eta*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*(297.0/4.0-243.0*xi+729.0/4.0*xi*xi+(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi)*eta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+2.0*(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+3.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 36.0-198.0*xi+324.0*xi*xi-162.0*xi*xi*xi+2.0*(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi)*eta+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta*eta+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi+(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-45.0+81.0*xi)*eta+(405.0/2.0-729.0/2.0*xi)*eta*eta+(-405.0/2.0+729.0/2.0*xi)*eta*eta*eta+((495.0/2.0-891.0/2.0*xi)*eta+(-4455.0/4.0+8019.0/4.0*xi)*eta*eta+(4455.0/4.0-8019.0/4.0*xi)*eta*eta*eta)*zeta+((-405.0+729.0*xi)*eta+(3645.0/2.0-6561.0/2.0*xi)*eta*eta+(-3645.0/2.0+6561.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((405.0/2.0-729.0/2.0*xi)*eta+(-3645.0/4.0+6561.0/4.0*xi)*eta*eta+(3645.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = 9.0-45.0*xi+81.0/2.0*xi*xi+2.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+3.0*(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta+(-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi+2.0*(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+3.0*(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta)*zeta+(81.0-405.0*xi+729.0/2.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi)*eta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta+(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = 9.0-45.0*xi+81.0/2.0*xi*xi+2.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+3.0*(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta+(-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi+2.0*(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+3.0*(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta)*zeta+(81.0-405.0*xi+729.0/2.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = -81.0*xi+405.0/2.0*xi*xi-243.0/2.0*xi*xi*xi+6.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(891.0/2.0*xi-4455.0/4.0*xi*xi+2673.0/4.0*xi*xi*xi+6.0*(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta)*zeta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi+6.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+6.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+2.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+3.0*(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi)*eta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta+(-891.0/4.0+4455.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+2.0*(891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta+3.0*(-891.0/4.0*xi+4455.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (36.0-81.0*xi)*eta+(-162.0+729.0/2.0*xi)*eta*eta+(162.0-729.0/2.0*xi)*eta*eta*eta+((-198.0+891.0/2.0*xi)*eta+(891.0-8019.0/4.0*xi)*eta*eta+(-891.0+8019.0/4.0*xi)*eta*eta*eta)*zeta+((324.0-729.0*xi)*eta+(-1458.0+6561.0/2.0*xi)*eta*eta+(1458.0-6561.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((-162.0+729.0/2.0*xi)*eta+(729.0-6561.0/4.0*xi)*eta*eta+(-729.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = -9.0/2.0+36.0*xi-81.0/2.0*xi*xi+2.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+3.0*(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta*eta+(99.0/4.0-198.0*xi+891.0/4.0*xi*xi+2.0*(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+3.0*(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi)*eta*eta)*zeta+(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (99.0/4.0-198.0*xi+891.0/4.0*xi*xi)*eta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta*eta+(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = -9.0/2.0+36.0*xi-81.0/2.0*xi*xi+2.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+3.0*(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta*eta+(99.0/4.0-198.0*xi+891.0/4.0*xi*xi+2.0*(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+3.0*(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi)*eta*eta)*zeta+(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = 81.0/2.0*xi-162.0*xi*xi+243.0/2.0*xi*xi*xi+6.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(-891.0/4.0*xi+891.0*xi*xi-2673.0/4.0*xi*xi*xi+6.0*(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta)*zeta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi+6.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi+6.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+2.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+3.0*(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (99.0/4.0-198.0*xi+891.0/4.0*xi*xi)*eta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta*eta+(891.0/8.0-891.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+2.0*(-891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta+3.0*(891.0/8.0*xi-891.0/2.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-81.0+243.0*xi)*eta+(729.0/2.0-2187.0/2.0*xi)*eta*eta+(-729.0/2.0+2187.0/2.0*xi)*eta*eta*eta)*zeta+((405.0/2.0-1215.0/2.0*xi)*eta+(-3645.0/4.0+10935.0/4.0*xi)*eta*eta+(3645.0/4.0-10935.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-243.0/2.0+729.0/2.0*xi)*eta+(2187.0/4.0-6561.0/4.0*xi)*eta*eta+(-2187.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (9.0-81.0*xi+243.0/2.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta+(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi+2.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi+2.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (9.0-81.0*xi+243.0/2.0*xi*xi+2.0*(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+3.0*(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta+(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi+2.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi+2.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi+6.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta)*zeta+(405.0/2.0*xi-3645.0/4.0*xi*xi+3645.0/4.0*xi*xi*xi+6.0*(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+6.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+2.0*(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((81.0/2.0-243.0/2.0*xi)*eta+(-729.0/4.0+2187.0/4.0*xi)*eta*eta+(729.0/4.0-2187.0/4.0*xi)*eta*eta*eta)*zeta+((-162.0+486.0*xi)*eta+(729.0-2187.0*xi)*eta*eta+(-729.0+2187.0*xi)*eta*eta*eta)*zeta*zeta+((243.0/2.0-729.0/2.0*xi)*eta+(-2187.0/4.0+6561.0/4.0*xi)*eta*eta+(2187.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+3.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta+(18.0-162.0*xi+243.0*xi*xi+2.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi+2.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta+2.0*((18.0-162.0*xi+243.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+3.0*(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta)*zeta+(18.0-162.0*xi+243.0*xi*xi+2.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi+2.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+6.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta)*zeta+(-162.0*xi+729.0*xi*xi-729.0*xi*xi*xi+6.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+6.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta*eta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta*eta*eta+2.0*((18.0-162.0*xi+243.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta*eta+2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-45.0+81.0*xi)*eta+(405.0/2.0-729.0/2.0*xi)*eta*eta+(-405.0/2.0+729.0/2.0*xi)*eta*eta*eta)*zeta+((405.0/2.0-729.0/2.0*xi)*eta+(-3645.0/4.0+6561.0/4.0*xi)*eta*eta+(3645.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-405.0/2.0+729.0/2.0*xi)*eta+(3645.0/4.0-6561.0/4.0*xi)*eta*eta+(-3645.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (9.0-45.0*xi+81.0/2.0*xi*xi+2.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+3.0*(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta)*zeta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi+2.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (9.0-45.0*xi+81.0/2.0*xi*xi)*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta+(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (9.0-45.0*xi+81.0/2.0*xi*xi+2.0*(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+3.0*(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta)*zeta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi+2.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-81.0*xi+405.0/2.0*xi*xi-243.0/2.0*xi*xi*xi+6.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta)*zeta+(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+6.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+6.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (9.0-45.0*xi+81.0/2.0*xi*xi)*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta+(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((36.0-81.0*xi)*eta+(-162.0+729.0/2.0*xi)*eta*eta+(162.0-729.0/2.0*xi)*eta*eta*eta)*zeta+((-162.0+729.0/2.0*xi)*eta+(729.0-6561.0/4.0*xi)*eta*eta+(-729.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((162.0-729.0/2.0*xi)*eta+(-729.0+6561.0/4.0*xi)*eta*eta+(729.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-9.0/2.0+36.0*xi-81.0/2.0*xi*xi+2.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+3.0*(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta*eta)*zeta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi+2.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-9.0/2.0+36.0*xi-81.0/2.0*xi*xi)*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta+(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+2.0*((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-9.0/2.0+36.0*xi-81.0/2.0*xi*xi+2.0*(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+3.0*(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta*eta)*zeta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi+2.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (81.0/2.0*xi-162.0*xi*xi+243.0/2.0*xi*xi*xi+6.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta)*zeta+(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi+6.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+6.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-9.0/2.0+36.0*xi-81.0/2.0*xi*xi)*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta+(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+2.0*((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((162.0-243.0*xi)*eta+(-729.0+2187.0/2.0*xi)*eta*eta+(729.0-2187.0/2.0*xi)*eta*eta*eta)*zeta+((-405.0+1215.0/2.0*xi)*eta+(3645.0/2.0-10935.0/4.0*xi)*eta*eta+(-3645.0/2.0+10935.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((243.0-729.0/2.0*xi)*eta+(-2187.0/2.0+6561.0/4.0*xi)*eta*eta+(2187.0/2.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta+(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi+2.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi+2.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+2.0*(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+3.0*(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta+(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi+2.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi+2.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi+6.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta)*zeta+(405.0/2.0-4455.0/4.0*xi+3645.0/2.0*xi*xi-3645.0/4.0*xi*xi*xi+6.0*(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi+6.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+2.0*(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-81.0+243.0/2.0*xi)*eta+(729.0/2.0-2187.0/4.0*xi)*eta*eta+(-729.0/2.0+2187.0/4.0*xi)*eta*eta*eta)*zeta+((324.0-486.0*xi)*eta+(-1458.0+2187.0*xi)*eta*eta+(1458.0-2187.0*xi)*eta*eta*eta)*zeta*zeta+((-243.0+729.0/2.0*xi)*eta+(2187.0/2.0-6561.0/4.0*xi)*eta*eta+(-2187.0/2.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+3.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta+(-99.0+324.0*xi-243.0*xi*xi+2.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(297.0/4.0-243.0*xi+729.0/4.0*xi*xi+2.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta+2.0*((-99.0+324.0*xi-243.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+3.0*(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta)*zeta+(-99.0+324.0*xi-243.0*xi*xi+2.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(297.0/4.0-243.0*xi+729.0/4.0*xi*xi+2.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi+6.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta)*zeta+(-162.0+891.0*xi-1458.0*xi*xi+729.0*xi*xi*xi+6.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi+6.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta*eta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta*eta*eta+2.0*((-99.0+324.0*xi-243.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta*eta+2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (162.0-243.0*xi)*eta+(-405.0+1215.0/2.0*xi)*eta*eta+(243.0-729.0/2.0*xi)*eta*eta*eta+((-891.0+2673.0/2.0*xi)*eta+(4455.0/2.0-13365.0/4.0*xi)*eta*eta+(-2673.0/2.0+8019.0/4.0*xi)*eta*eta*eta)*zeta+((1458.0-2187.0*xi)*eta+(-3645.0+10935.0/2.0*xi)*eta*eta+(2187.0-6561.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((-729.0+2187.0/2.0*xi)*eta+(3645.0/2.0-10935.0/4.0*xi)*eta*eta+(-2187.0/2.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = -99.0/2.0+162.0*xi-243.0/2.0*xi*xi+2.0*(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta+3.0*(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta*eta+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi+2.0*(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi)*eta+3.0*(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi)*eta*eta)*zeta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi+2.0*(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta+3.0*(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi)*eta*eta+(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta*eta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = -99.0/2.0+162.0*xi-243.0/2.0*xi*xi+2.0*(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta+3.0*(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta*eta+(1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi+2.0*(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi)*eta+3.0*(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi)*eta*eta)*zeta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi+2.0*(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta+3.0*(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = -45.0+495.0/2.0*xi-405.0*xi*xi+405.0/2.0*xi*xi*xi+6.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(495.0/2.0-5445.0/4.0*xi+4455.0/2.0*xi*xi-4455.0/4.0*xi*xi*xi+6.0*(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta)*zeta+(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi+6.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(405.0/2.0-4455.0/4.0*xi+3645.0/2.0*xi*xi-3645.0/4.0*xi*xi*xi+6.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi+2.0*(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi)*eta+3.0*(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (1089.0/4.0-891.0*xi+2673.0/4.0*xi*xi)*eta+(-5445.0/8.0+4455.0/2.0*xi-13365.0/8.0*xi*xi)*eta*eta+(3267.0/8.0-2673.0/2.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta*eta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -99.0/2.0+1089.0/4.0*xi-891.0/2.0*xi*xi+891.0/4.0*xi*xi*xi+2.0*(495.0/4.0-5445.0/8.0*xi+4455.0/4.0*xi*xi-4455.0/8.0*xi*xi*xi)*eta+3.0*(-297.0/4.0+3267.0/8.0*xi-2673.0/4.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta*eta+2.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-81.0+243.0/2.0*xi)*eta+(324.0-486.0*xi)*eta*eta+(-243.0+729.0/2.0*xi)*eta*eta*eta+((891.0/2.0-2673.0/4.0*xi)*eta+(-1782.0+2673.0*xi)*eta*eta+(2673.0/2.0-8019.0/4.0*xi)*eta*eta*eta)*zeta+((-729.0+2187.0/2.0*xi)*eta+(2916.0-4374.0*xi)*eta*eta+(-2187.0+6561.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((729.0/2.0-2187.0/4.0*xi)*eta+(-1458.0+2187.0*xi)*eta*eta+(2187.0/2.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = 99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-99.0+324.0*xi-243.0*xi*xi)*eta+3.0*(297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta*eta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi+2.0*(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi)*eta+3.0*(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi)*eta*eta)*zeta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-891.0+2916.0*xi-2187.0*xi*xi)*eta+3.0*(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi+2.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi)*eta*eta+(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-891.0+2916.0*xi-2187.0*xi*xi)*eta*eta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = 99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-99.0+324.0*xi-243.0*xi*xi)*eta+3.0*(297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta*eta+(-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi+2.0*(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi)*eta+3.0*(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi)*eta*eta)*zeta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-891.0+2916.0*xi-2187.0*xi*xi)*eta+3.0*(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi+2.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = 36.0-198.0*xi+324.0*xi*xi-162.0*xi*xi*xi+6.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-198.0+1089.0*xi-1782.0*xi*xi+891.0*xi*xi*xi+6.0*(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta)*zeta+(324.0-1782.0*xi+2916.0*xi*xi-1458.0*xi*xi*xi+6.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(-162.0+891.0*xi-1458.0*xi*xi+729.0*xi*xi*xi+6.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi)*eta+3.0*(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-1089.0/8.0+891.0/2.0*xi-2673.0/8.0*xi*xi)*eta+(1089.0/2.0-1782.0*xi+2673.0/2.0*xi*xi)*eta*eta+(-3267.0/8.0+2673.0/2.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-891.0+2916.0*xi-2187.0*xi*xi)*eta*eta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 99.0/4.0-1089.0/8.0*xi+891.0/4.0*xi*xi-891.0/8.0*xi*xi*xi+2.0*(-99.0+1089.0/2.0*xi-891.0*xi*xi+891.0/2.0*xi*xi*xi)*eta+3.0*(297.0/4.0-3267.0/8.0*xi+2673.0/4.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta*eta+2.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-81.0+243.0*xi)*eta+(405.0/2.0-1215.0/2.0*xi)*eta*eta+(-243.0/2.0+729.0/2.0*xi)*eta*eta*eta+((891.0/2.0-2673.0/2.0*xi)*eta+(-4455.0/4.0+13365.0/4.0*xi)*eta*eta+(2673.0/4.0-8019.0/4.0*xi)*eta*eta*eta)*zeta+((-729.0+2187.0*xi)*eta+(3645.0/2.0-10935.0/2.0*xi)*eta*eta+(-2187.0/2.0+6561.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((729.0/2.0-2187.0/2.0*xi)*eta+(-3645.0/4.0+10935.0/4.0*xi)*eta*eta+(2187.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = 9.0-81.0*xi+243.0/2.0*xi*xi+2.0*(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta+3.0*(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi+2.0*(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi)*eta+3.0*(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta)*zeta+(81.0-729.0*xi+2187.0/2.0*xi*xi+2.0*(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta+3.0*(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi)*eta*eta+(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta*eta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = 9.0-81.0*xi+243.0/2.0*xi*xi+2.0*(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta+3.0*(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta+(-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi+2.0*(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi)*eta+3.0*(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta)*zeta+(81.0-729.0*xi+2187.0/2.0*xi*xi+2.0*(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta+3.0*(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = -45.0*xi+405.0/2.0*xi*xi-405.0/2.0*xi*xi*xi+6.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(495.0/2.0*xi-4455.0/4.0*xi*xi+4455.0/4.0*xi*xi*xi+6.0*(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta)*zeta+(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi+6.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(405.0/2.0*xi-3645.0/4.0*xi*xi+3645.0/4.0*xi*xi*xi+6.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi+2.0*(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi)*eta+3.0*(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-99.0/2.0+891.0/2.0*xi-2673.0/4.0*xi*xi)*eta+(495.0/4.0-4455.0/4.0*xi+13365.0/8.0*xi*xi)*eta*eta+(-297.0/4.0+2673.0/4.0*xi-8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta*eta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -99.0/2.0*xi+891.0/4.0*xi*xi-891.0/4.0*xi*xi*xi+2.0*(495.0/4.0*xi-4455.0/8.0*xi*xi+4455.0/8.0*xi*xi*xi)*eta+3.0*(-297.0/4.0*xi+2673.0/8.0*xi*xi-2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta*eta+2.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (81.0/2.0-243.0/2.0*xi)*eta+(-162.0+486.0*xi)*eta*eta+(243.0/2.0-729.0/2.0*xi)*eta*eta*eta+((-891.0/4.0+2673.0/4.0*xi)*eta+(891.0-2673.0*xi)*eta*eta+(-2673.0/4.0+8019.0/4.0*xi)*eta*eta*eta)*zeta+((729.0/2.0-2187.0/2.0*xi)*eta+(-1458.0+4374.0*xi)*eta*eta+(2187.0/2.0-6561.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((-729.0/4.0+2187.0/4.0*xi)*eta+(729.0-2187.0*xi)*eta*eta+(-2187.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = -9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(18.0-162.0*xi+243.0*xi*xi)*eta+3.0*(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi+2.0*(-99.0+891.0*xi-2673.0/2.0*xi*xi)*eta+3.0*(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta)*zeta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(162.0-1458.0*xi+2187.0*xi*xi)*eta+3.0*(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi+2.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-99.0+891.0*xi-2673.0/2.0*xi*xi)*eta*eta+(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(162.0-1458.0*xi+2187.0*xi*xi)*eta*eta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = -9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(18.0-162.0*xi+243.0*xi*xi)*eta+3.0*(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta+(99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi+2.0*(-99.0+891.0*xi-2673.0/2.0*xi*xi)*eta+3.0*(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta)*zeta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(162.0-1458.0*xi+2187.0*xi*xi)*eta+3.0*(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi+2.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = 36.0*xi-162.0*xi*xi+162.0*xi*xi*xi+6.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(-198.0*xi+891.0*xi*xi-891.0*xi*xi*xi+6.0*(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta)*zeta+(324.0*xi-1458.0*xi*xi+1458.0*xi*xi*xi+6.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(-162.0*xi+729.0*xi*xi-729.0*xi*xi*xi+6.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi)*eta+3.0*(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (99.0/4.0-891.0/4.0*xi+2673.0/8.0*xi*xi)*eta+(-99.0+891.0*xi-2673.0/2.0*xi*xi)*eta*eta+(297.0/4.0-2673.0/4.0*xi+8019.0/8.0*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(162.0-1458.0*xi+2187.0*xi*xi)*eta*eta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 99.0/4.0*xi-891.0/8.0*xi*xi+891.0/8.0*xi*xi*xi+2.0*(-99.0*xi+891.0/2.0*xi*xi-891.0/2.0*xi*xi*xi)*eta+3.0*(297.0/4.0*xi-2673.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta*eta+2.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-81.0+243.0*xi)*eta+(405.0/2.0-1215.0/2.0*xi)*eta*eta+(-243.0/2.0+729.0/2.0*xi)*eta*eta*eta)*zeta+((729.0/2.0-2187.0/2.0*xi)*eta+(-3645.0/4.0+10935.0/4.0*xi)*eta*eta+(2187.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-729.0/2.0+2187.0/2.0*xi)*eta+(3645.0/4.0-10935.0/4.0*xi)*eta*eta+(-2187.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (9.0-81.0*xi+243.0/2.0*xi*xi+2.0*(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta+3.0*(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta)*zeta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi+2.0*(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta*eta+(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta+(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (9.0-81.0*xi+243.0/2.0*xi*xi+2.0*(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta+3.0*(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta)*zeta+(-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi+2.0*(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-45.0*xi+405.0/2.0*xi*xi-405.0/2.0*xi*xi*xi+6.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta)*zeta+(405.0/2.0*xi-3645.0/4.0*xi*xi+3645.0/4.0*xi*xi*xi+6.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi+6.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta*eta+(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+2.0*((-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((81.0/2.0-729.0/2.0*xi+2187.0/4.0*xi*xi)*eta+(-405.0/4.0+3645.0/4.0*xi-10935.0/8.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+2.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((81.0/2.0*xi-729.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(-405.0/4.0*xi+3645.0/8.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((81.0/2.0-243.0/2.0*xi)*eta+(-162.0+486.0*xi)*eta*eta+(243.0/2.0-729.0/2.0*xi)*eta*eta*eta)*zeta+((-729.0/4.0+2187.0/4.0*xi)*eta+(729.0-2187.0*xi)*eta*eta+(-2187.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((729.0/4.0-2187.0/4.0*xi)*eta+(-729.0+2187.0*xi)*eta*eta+(2187.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(18.0-162.0*xi+243.0*xi*xi)*eta+3.0*(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta)*zeta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi+2.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi+2.0*(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(18.0-162.0*xi+243.0*xi*xi)*eta*eta+(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+2.0*((81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi+2.0*(18.0-162.0*xi+243.0*xi*xi)*eta+3.0*(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta)*zeta+(81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi+2.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi+2.0*(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (36.0*xi-162.0*xi*xi+162.0*xi*xi*xi+6.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta)*zeta+(-162.0*xi+729.0*xi*xi-729.0*xi*xi*xi+6.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi+6.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(18.0-162.0*xi+243.0*xi*xi)*eta*eta+(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+2.0*((81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-81.0/4.0+729.0/4.0*xi-2187.0/8.0*xi*xi)*eta+(81.0-729.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+2.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-81.0/4.0*xi+729.0/8.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+(81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((162.0-243.0*xi)*eta+(-405.0+1215.0/2.0*xi)*eta*eta+(243.0-729.0/2.0*xi)*eta*eta*eta)*zeta+((-729.0+2187.0/2.0*xi)*eta+(3645.0/2.0-10935.0/4.0*xi)*eta*eta+(-2187.0/2.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((729.0-2187.0/2.0*xi)*eta+(-3645.0/2.0+10935.0/4.0*xi)*eta*eta+(2187.0/2.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+2.0*(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta+3.0*(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta*eta)*zeta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi+2.0*(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta*eta+(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+2.0*((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta+(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-99.0/2.0+162.0*xi-243.0/2.0*xi*xi+2.0*(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta+3.0*(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta*eta)*zeta+(891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi+2.0*(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-45.0+495.0/2.0*xi-405.0*xi*xi+405.0/2.0*xi*xi*xi+6.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta)*zeta+(405.0/2.0-4455.0/4.0*xi+3645.0/2.0*xi*xi-3645.0/4.0*xi*xi*xi+6.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi+6.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta*eta+(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta*eta*eta+2.0*((891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-891.0/4.0+729.0*xi-2187.0/4.0*xi*xi)*eta+(4455.0/8.0-3645.0/2.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta*eta+2.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((81.0/2.0-891.0/4.0*xi+729.0/2.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(-405.0/4.0+4455.0/8.0*xi-3645.0/4.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta*eta+(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-81.0+243.0/2.0*xi)*eta+(324.0-486.0*xi)*eta*eta+(-243.0+729.0/2.0*xi)*eta*eta*eta)*zeta+((729.0/2.0-2187.0/4.0*xi)*eta+(-1458.0+2187.0*xi)*eta*eta+(2187.0/2.0-6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-729.0/2.0+2187.0/4.0*xi)*eta+(1458.0-2187.0*xi)*eta*eta+(-2187.0/2.0+6561.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-99.0+324.0*xi-243.0*xi*xi)*eta+3.0*(297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta*eta)*zeta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi+2.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi+2.0*(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-99.0+324.0*xi-243.0*xi*xi)*eta*eta+(297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+2.0*((-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (99.0/4.0-81.0*xi+243.0/4.0*xi*xi+2.0*(-99.0+324.0*xi-243.0*xi*xi)*eta+3.0*(297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta*eta)*zeta+(-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi+2.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi+2.0*(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (36.0-198.0*xi+324.0*xi*xi-162.0*xi*xi*xi+6.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta)*zeta+(-162.0+891.0*xi-1458.0*xi*xi+729.0*xi*xi*xi+6.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi+6.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-99.0+324.0*xi-243.0*xi*xi)*eta*eta+(297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta*eta*eta+2.0*((-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((891.0/8.0-729.0/2.0*xi+2187.0/8.0*xi*xi)*eta+(-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi)*eta+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta*eta+2.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-81.0/4.0+891.0/8.0*xi-729.0/4.0*xi*xi+729.0/8.0*xi*xi*xi)*eta+(81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi)*eta*eta+(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-405.0+729.0*xi+(4455.0/2.0-8019.0/2.0*xi)*eta+(-3645.0+6561.0*xi)*eta*eta+(3645.0/2.0-6561.0/2.0*xi)*eta*eta*eta)*zeta+(2025.0/2.0-3645.0/2.0*xi+(-22275.0/4.0+40095.0/4.0*xi)*eta+(18225.0/2.0-32805.0/2.0*xi)*eta*eta+(-18225.0/4.0+32805.0/4.0*xi)*eta*eta*eta)*zeta*zeta+(-1215.0/2.0+2187.0/2.0*xi+(13365.0/4.0-24057.0/4.0*xi)*eta+(-10935.0/2.0+19683.0/2.0*xi)*eta*eta+(10935.0/4.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi+2.0*(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta+(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi+2.0*(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta+3.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi+2.0*(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = 81.0-405.0*xi+729.0/2.0*xi*xi+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta+2.0*(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi+(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi)*eta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi+(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi)*eta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi+2.0*(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta+(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi+2.0*(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta+3.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi+2.0*(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi+6.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta)*zeta+(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi+6.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi+6.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+3.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi+2.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = 81.0-405.0*xi+729.0/2.0*xi*xi+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta+2.0*(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi+(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi)*eta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi+(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi)*eta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+3.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi+2.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = -405.0*xi+2025.0/2.0*xi*xi-1215.0/2.0*xi*xi*xi+2.0*(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi)*eta+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta*eta+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta+(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (324.0-729.0*xi+(-1782.0+8019.0/2.0*xi)*eta+(2916.0-6561.0*xi)*eta*eta+(-1458.0+6561.0/2.0*xi)*eta*eta*eta)*zeta+(-810.0+3645.0/2.0*xi+(4455.0-40095.0/4.0*xi)*eta+(-7290.0+32805.0/2.0*xi)*eta*eta+(3645.0-32805.0/4.0*xi)*eta*eta*eta)*zeta*zeta+(486.0-2187.0/2.0*xi+(-2673.0+24057.0/4.0*xi)*eta+(4374.0-19683.0/2.0*xi)*eta*eta+(-2187.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi+2.0*(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta+(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi+2.0*(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta+3.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi+2.0*(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = -81.0/2.0+324.0*xi-729.0/2.0*xi*xi+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta+2.0*(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi+(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi)*eta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi+(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi)*eta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi+2.0*(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta+(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi+2.0*(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta+3.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi+2.0*(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi+6.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta)*zeta+(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi+6.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi+6.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+3.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi+2.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = -81.0/2.0+324.0*xi-729.0/2.0*xi*xi+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta+2.0*(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi+(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi)*eta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi+(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi)*eta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+3.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi+2.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 405.0/2.0*xi-810.0*xi*xi+1215.0/2.0*xi*xi*xi+2.0*(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi)*eta+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta*eta+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi+(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta+(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (405.0/2.0-729.0/2.0*xi+(-4455.0/4.0+8019.0/4.0*xi)*eta+(3645.0/2.0-6561.0/2.0*xi)*eta*eta+(-3645.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta+(-810.0+1458.0*xi+(4455.0-8019.0*xi)*eta+(-7290.0+13122.0*xi)*eta*eta+(3645.0-6561.0*xi)*eta*eta*eta)*zeta*zeta+(1215.0/2.0-2187.0/2.0*xi+(-13365.0/4.0+24057.0/4.0*xi)*eta+(10935.0/2.0-19683.0/2.0*xi)*eta*eta+(-10935.0/4.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta+(-891.0+4455.0*xi-8019.0/2.0*xi*xi+2.0*(1458.0-7290.0*xi+6561.0*xi*xi)*eta+3.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi+2.0*(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = -81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta+2.0*(162.0-810.0*xi+729.0*xi*xi+(-891.0+4455.0*xi-8019.0/2.0*xi*xi)*eta+(1458.0-7290.0*xi+6561.0*xi*xi)*eta*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi+(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi)*eta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta+(-891.0+4455.0*xi-8019.0/2.0*xi*xi+2.0*(1458.0-7290.0*xi+6561.0*xi*xi)*eta+3.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi+2.0*(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi+6.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta+(2916.0*xi-7290.0*xi*xi+4374.0*xi*xi*xi+6.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi+6.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+3.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi+2.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = -81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta+2.0*(162.0-810.0*xi+729.0*xi*xi+(-891.0+4455.0*xi-8019.0/2.0*xi*xi)*eta+(1458.0-7290.0*xi+6561.0*xi*xi)*eta*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi+(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi)*eta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+3.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi+2.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 324.0*xi-810.0*xi*xi+486.0*xi*xi*xi+2.0*(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi)*eta+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta*eta+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta+(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-162.0+729.0/2.0*xi+(891.0-8019.0/4.0*xi)*eta+(-1458.0+6561.0/2.0*xi)*eta*eta+(729.0-6561.0/4.0*xi)*eta*eta*eta)*zeta+(648.0-1458.0*xi+(-3564.0+8019.0*xi)*eta+(5832.0-13122.0*xi)*eta*eta+(-2916.0+6561.0*xi)*eta*eta*eta)*zeta*zeta+(-486.0+2187.0/2.0*xi+(2673.0-24057.0/4.0*xi)*eta+(-4374.0+19683.0/2.0*xi)*eta*eta+(2187.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta+(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi+2.0*(-729.0+5832.0*xi-6561.0*xi*xi)*eta+3.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi+2.0*(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = 81.0/4.0-162.0*xi+729.0/4.0*xi*xi+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta+2.0*(-81.0+648.0*xi-729.0*xi*xi+(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi)*eta+(-729.0+5832.0*xi-6561.0*xi*xi)*eta*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi+(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi)*eta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta+(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi+2.0*(-729.0+5832.0*xi-6561.0*xi*xi)*eta+3.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi+2.0*(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi+6.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta+(-1458.0*xi+5832.0*xi*xi-4374.0*xi*xi*xi+6.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi+6.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+3.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi+2.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = 81.0/4.0-162.0*xi+729.0/4.0*xi*xi+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta+2.0*(-81.0+648.0*xi-729.0*xi*xi+(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi)*eta+(-729.0+5832.0*xi-6561.0*xi*xi)*eta*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi+(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi)*eta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+3.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi+2.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = -162.0*xi+648.0*xi*xi-486.0*xi*xi*xi+2.0*(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi)*eta+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta*eta+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi+(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta+(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-405.0+729.0*xi)*eta+(3645.0/2.0-6561.0/2.0*xi)*eta*eta+(-3645.0/2.0+6561.0/2.0*xi)*eta*eta*eta)*zeta+((2025.0/2.0-3645.0/2.0*xi)*eta+(-18225.0/4.0+32805.0/4.0*xi)*eta*eta+(18225.0/4.0-32805.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-1215.0/2.0+2187.0/2.0*xi)*eta+(10935.0/4.0-19683.0/4.0*xi)*eta*eta+(-10935.0/4.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (81.0-405.0*xi+729.0/2.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta+(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi+2.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi+2.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (81.0-405.0*xi+729.0/2.0*xi*xi+2.0*(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+3.0*(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta+(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi+2.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi+2.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi+6.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta)*zeta+(3645.0/2.0*xi-18225.0/4.0*xi*xi+10935.0/4.0*xi*xi*xi+6.0*(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi+6.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+3.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+2.0*(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((324.0-729.0*xi)*eta+(-1458.0+6561.0/2.0*xi)*eta*eta+(1458.0-6561.0/2.0*xi)*eta*eta*eta)*zeta+((-810.0+3645.0/2.0*xi)*eta+(3645.0-32805.0/4.0*xi)*eta*eta+(-3645.0+32805.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((486.0-2187.0/2.0*xi)*eta+(-2187.0+19683.0/4.0*xi)*eta*eta+(2187.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta+(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi+2.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi+2.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+2.0*(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+3.0*(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta+(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi+2.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi+2.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi+6.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta)*zeta+(-3645.0/4.0*xi+3645.0*xi*xi-10935.0/4.0*xi*xi*xi+6.0*(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi+6.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta*eta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+2.0*(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((405.0/2.0-729.0/2.0*xi)*eta+(-3645.0/4.0+6561.0/4.0*xi)*eta*eta+(3645.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta+((-810.0+1458.0*xi)*eta+(3645.0-6561.0*xi)*eta*eta+(-3645.0+6561.0*xi)*eta*eta*eta)*zeta*zeta+((1215.0/2.0-2187.0/2.0*xi)*eta+(-10935.0/4.0+19683.0/4.0*xi)*eta*eta+(10935.0/4.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta+(162.0-810.0*xi+729.0*xi*xi+2.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((162.0-810.0*xi+729.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+3.0*(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta+(162.0-810.0*xi+729.0*xi*xi+2.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+6.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta+(-1458.0*xi+3645.0*xi*xi-2187.0*xi*xi*xi+6.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi+6.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((162.0-810.0*xi+729.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-162.0+729.0/2.0*xi)*eta+(729.0-6561.0/4.0*xi)*eta*eta+(-729.0+6561.0/4.0*xi)*eta*eta*eta)*zeta+((648.0-1458.0*xi)*eta+(-2916.0+6561.0*xi)*eta*eta+(2916.0-6561.0*xi)*eta*eta*eta)*zeta*zeta+((-486.0+2187.0/2.0*xi)*eta+(2187.0-19683.0/4.0*xi)*eta*eta+(-2187.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta+(-81.0+648.0*xi-729.0*xi*xi+2.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi+2.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((-81.0+648.0*xi-729.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+3.0*(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta+(-81.0+648.0*xi-729.0*xi*xi+2.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi+2.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi+6.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta+(729.0*xi-2916.0*xi*xi+2187.0*xi*xi*xi+6.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi+6.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta*eta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((-81.0+648.0*xi-729.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-405.0+729.0*xi)*eta+(2025.0/2.0-3645.0/2.0*xi)*eta*eta+(-1215.0/2.0+2187.0/2.0*xi)*eta*eta*eta+((4455.0/2.0-8019.0/2.0*xi)*eta+(-22275.0/4.0+40095.0/4.0*xi)*eta*eta+(13365.0/4.0-24057.0/4.0*xi)*eta*eta*eta)*zeta+((-3645.0+6561.0*xi)*eta+(18225.0/2.0-32805.0/2.0*xi)*eta*eta+(-10935.0/2.0+19683.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((3645.0/2.0-6561.0/2.0*xi)*eta+(-18225.0/4.0+32805.0/4.0*xi)*eta*eta+(10935.0/4.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = 81.0-405.0*xi+729.0/2.0*xi*xi+2.0*(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta+3.0*(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi+2.0*(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi)*eta+3.0*(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi)*eta*eta)*zeta+(729.0-3645.0*xi+6561.0/2.0*xi*xi+2.0*(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta+3.0*(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi)*eta*eta+(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi)*eta*eta*eta+2.0*((729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta*eta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = 81.0-405.0*xi+729.0/2.0*xi*xi+2.0*(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta+3.0*(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi+2.0*(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi)*eta+3.0*(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi)*eta*eta)*zeta+(729.0-3645.0*xi+6561.0/2.0*xi*xi+2.0*(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta+3.0*(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = -405.0*xi+2025.0/2.0*xi*xi-1215.0/2.0*xi*xi*xi+6.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(4455.0/2.0*xi-22275.0/4.0*xi*xi+13365.0/4.0*xi*xi*xi+6.0*(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta)*zeta+(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi+6.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(3645.0/2.0*xi-18225.0/4.0*xi*xi+10935.0/4.0*xi*xi*xi+6.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi+2.0*(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi)*eta+3.0*(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-891.0/2.0+4455.0/2.0*xi-8019.0/4.0*xi*xi)*eta+(4455.0/4.0-22275.0/4.0*xi+40095.0/8.0*xi*xi)*eta*eta+(-2673.0/4.0+13365.0/4.0*xi-24057.0/8.0*xi*xi)*eta*eta*eta+2.0*((729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta*eta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -891.0/2.0*xi+4455.0/4.0*xi*xi-2673.0/4.0*xi*xi*xi+2.0*(4455.0/4.0*xi-22275.0/8.0*xi*xi+13365.0/8.0*xi*xi*xi)*eta+3.0*(-2673.0/4.0*xi+13365.0/8.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta*eta+2.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (324.0-729.0*xi)*eta+(-810.0+3645.0/2.0*xi)*eta*eta+(486.0-2187.0/2.0*xi)*eta*eta*eta+((-1782.0+8019.0/2.0*xi)*eta+(4455.0-40095.0/4.0*xi)*eta*eta+(-2673.0+24057.0/4.0*xi)*eta*eta*eta)*zeta+((2916.0-6561.0*xi)*eta+(-7290.0+32805.0/2.0*xi)*eta*eta+(4374.0-19683.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((-1458.0+6561.0/2.0*xi)*eta+(3645.0-32805.0/4.0*xi)*eta*eta+(-2187.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = -81.0/2.0+324.0*xi-729.0/2.0*xi*xi+2.0*(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta+3.0*(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta*eta+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi+2.0*(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi)*eta*eta)*zeta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi+2.0*(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta+3.0*(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi)*eta*eta*eta+2.0*((-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta*eta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = -81.0/2.0+324.0*xi-729.0/2.0*xi*xi+2.0*(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta+3.0*(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta*eta+(891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi+2.0*(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi)*eta*eta)*zeta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi+2.0*(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta+3.0*(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = 405.0/2.0*xi-810.0*xi*xi+1215.0/2.0*xi*xi*xi+6.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(-4455.0/4.0*xi+4455.0*xi*xi-13365.0/4.0*xi*xi*xi+6.0*(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta)*zeta+(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi+6.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(-3645.0/4.0*xi+3645.0*xi*xi-10935.0/4.0*xi*xi*xi+6.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi+2.0*(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi)*eta+3.0*(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (891.0/4.0-1782.0*xi+8019.0/4.0*xi*xi)*eta+(-4455.0/8.0+4455.0*xi-40095.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2673.0*xi+24057.0/8.0*xi*xi)*eta*eta*eta+2.0*((-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta*eta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 891.0/4.0*xi-891.0*xi*xi+2673.0/4.0*xi*xi*xi+2.0*(-4455.0/8.0*xi+4455.0/2.0*xi*xi-13365.0/8.0*xi*xi*xi)*eta+3.0*(2673.0/8.0*xi-2673.0/2.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta*eta+2.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (405.0/2.0-729.0/2.0*xi)*eta+(-810.0+1458.0*xi)*eta*eta+(1215.0/2.0-2187.0/2.0*xi)*eta*eta*eta+((-4455.0/4.0+8019.0/4.0*xi)*eta+(4455.0-8019.0*xi)*eta*eta+(-13365.0/4.0+24057.0/4.0*xi)*eta*eta*eta)*zeta+((3645.0/2.0-6561.0/2.0*xi)*eta+(-7290.0+13122.0*xi)*eta*eta+(10935.0/2.0-19683.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((-3645.0/4.0+6561.0/4.0*xi)*eta+(3645.0-6561.0*xi)*eta*eta+(-10935.0/4.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = -81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(162.0-810.0*xi+729.0*xi*xi)*eta+3.0*(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-891.0+4455.0*xi-8019.0/2.0*xi*xi)*eta+3.0*(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi)*eta*eta)*zeta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(1458.0-7290.0*xi+6561.0*xi*xi)*eta+3.0*(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi+2.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-891.0+4455.0*xi-8019.0/2.0*xi*xi)*eta*eta+(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi)*eta*eta*eta+2.0*((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(1458.0-7290.0*xi+6561.0*xi*xi)*eta*eta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = -81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(162.0-810.0*xi+729.0*xi*xi)*eta+3.0*(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta+(891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi+2.0*(-891.0+4455.0*xi-8019.0/2.0*xi*xi)*eta+3.0*(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi)*eta*eta)*zeta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(1458.0-7290.0*xi+6561.0*xi*xi)*eta+3.0*(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi+2.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = 324.0*xi-810.0*xi*xi+486.0*xi*xi*xi+6.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta+(-1782.0*xi+4455.0*xi*xi-2673.0*xi*xi*xi+6.0*(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta)*zeta+(2916.0*xi-7290.0*xi*xi+4374.0*xi*xi*xi+6.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(-1458.0*xi+3645.0*xi*xi-2187.0*xi*xi*xi+6.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi)*eta+3.0*(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+3.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (891.0/4.0-4455.0/4.0*xi+8019.0/8.0*xi*xi)*eta+(-891.0+4455.0*xi-8019.0/2.0*xi*xi)*eta*eta+(2673.0/4.0-13365.0/4.0*xi+24057.0/8.0*xi*xi)*eta*eta*eta+2.0*((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(1458.0-7290.0*xi+6561.0*xi*xi)*eta*eta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 891.0/4.0*xi-4455.0/8.0*xi*xi+2673.0/8.0*xi*xi*xi+2.0*(-891.0*xi+4455.0/2.0*xi*xi-2673.0/2.0*xi*xi*xi)*eta+3.0*(2673.0/4.0*xi-13365.0/8.0*xi*xi+8019.0/8.0*xi*xi*xi)*eta*eta+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+3.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta*eta+2.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = (-162.0+729.0/2.0*xi)*eta+(648.0-1458.0*xi)*eta*eta+(-486.0+2187.0/2.0*xi)*eta*eta*eta+((891.0-8019.0/4.0*xi)*eta+(-3564.0+8019.0*xi)*eta*eta+(2673.0-24057.0/4.0*xi)*eta*eta*eta)*zeta+((-1458.0+6561.0/2.0*xi)*eta+(5832.0-13122.0*xi)*eta*eta+(-4374.0+19683.0/2.0*xi)*eta*eta*eta)*zeta*zeta+((729.0-6561.0/4.0*xi)*eta+(-2916.0+6561.0*xi)*eta*eta+(2187.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = 81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-81.0+648.0*xi-729.0*xi*xi)*eta+3.0*(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi+2.0*(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi)*eta+3.0*(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi)*eta*eta)*zeta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-729.0+5832.0*xi-6561.0*xi*xi)*eta+3.0*(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi+2.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi)*eta*eta*eta+2.0*((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-729.0+5832.0*xi-6561.0*xi*xi)*eta*eta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = 81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-81.0+648.0*xi-729.0*xi*xi)*eta+3.0*(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta*eta+(-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi+2.0*(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi)*eta+3.0*(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi)*eta*eta)*zeta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-729.0+5832.0*xi-6561.0*xi*xi)*eta+3.0*(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta)*zeta*zeta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi+2.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = -162.0*xi+648.0*xi*xi-486.0*xi*xi*xi+6.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta+(891.0*xi-3564.0*xi*xi+2673.0*xi*xi*xi+6.0*(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta)*zeta+(-1458.0*xi+5832.0*xi*xi-4374.0*xi*xi*xi+6.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta)*zeta*zeta+(729.0*xi-2916.0*xi*xi+2187.0*xi*xi*xi+6.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi)*eta+3.0*(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-891.0/8.0+891.0*xi-8019.0/8.0*xi*xi)*eta+(891.0/2.0-3564.0*xi+8019.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2673.0*xi-24057.0/8.0*xi*xi)*eta*eta*eta+2.0*((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-729.0+5832.0*xi-6561.0*xi*xi)*eta*eta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -891.0/8.0*xi+891.0/2.0*xi*xi-2673.0/8.0*xi*xi*xi+2.0*(891.0/2.0*xi-1782.0*xi*xi+2673.0/2.0*xi*xi*xi)*eta+3.0*(-2673.0/8.0*xi+2673.0/2.0*xi*xi-8019.0/8.0*xi*xi*xi)*eta*eta+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta*eta+2.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta*eta+6.0*((-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-729.0+2187.0*xi)*eta+(3645.0/2.0-10935.0/2.0*xi)*eta*eta+(-2187.0/2.0+6561.0/2.0*xi)*eta*eta*eta)*zeta+((3645.0/2.0-10935.0/2.0*xi)*eta+(-18225.0/4.0+54675.0/4.0*xi)*eta*eta+(10935.0/4.0-32805.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-2187.0/2.0+6561.0/2.0*xi)*eta+(10935.0/4.0-32805.0/4.0*xi)*eta*eta+(-6561.0/4.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (81.0-729.0*xi+2187.0/2.0*xi*xi+2.0*(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta+3.0*(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi+2.0*(2025.0/4.0-18225.0/4.0*xi+54675.0/8.0*xi*xi)*eta+3.0*(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi+2.0*(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta*eta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta+(2025.0/4.0-18225.0/4.0*xi+54675.0/8.0*xi*xi)*eta*eta+(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta+(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta+(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (81.0-729.0*xi+2187.0/2.0*xi*xi+2.0*(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta+3.0*(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi+2.0*(2025.0/4.0-18225.0/4.0*xi+54675.0/8.0*xi*xi)*eta+3.0*(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi+2.0*(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi+6.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta)*zeta+(2025.0/2.0*xi-18225.0/4.0*xi*xi+18225.0/4.0*xi*xi*xi+6.0*(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-1215.0/2.0*xi+10935.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi+6.0*(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi+2.0*(2025.0/4.0*xi-18225.0/8.0*xi*xi+18225.0/8.0*xi*xi*xi)*eta+3.0*(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (81.0-729.0*xi+2187.0/2.0*xi*xi)*eta+(-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta*eta+(243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((-405.0/2.0+3645.0/2.0*xi-10935.0/4.0*xi*xi)*eta+(2025.0/4.0-18225.0/4.0*xi+54675.0/8.0*xi*xi)*eta*eta+(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/2.0-2187.0/2.0*xi+6561.0/4.0*xi*xi)*eta+(-1215.0/4.0+10935.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta+(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 81.0*xi-729.0/2.0*xi*xi+729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi+2.0*(2025.0/4.0*xi-18225.0/8.0*xi*xi+18225.0/8.0*xi*xi*xi)*eta+3.0*(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-405.0/2.0*xi+3645.0/4.0*xi*xi-3645.0/4.0*xi*xi*xi)*eta+2.0*(2025.0/4.0*xi-18225.0/8.0*xi*xi+18225.0/8.0*xi*xi*xi)*eta*eta+2.0*(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((243.0/2.0*xi-2187.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-1215.0/4.0*xi+10935.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((729.0/2.0-2187.0/2.0*xi)*eta+(-1458.0+4374.0*xi)*eta*eta+(2187.0/2.0-6561.0/2.0*xi)*eta*eta*eta)*zeta+((-3645.0/4.0+10935.0/4.0*xi)*eta+(3645.0-10935.0*xi)*eta*eta+(-10935.0/4.0+32805.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((2187.0/4.0-6561.0/4.0*xi)*eta+(-2187.0+6561.0*xi)*eta*eta+(6561.0/4.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(162.0-1458.0*xi+2187.0*xi*xi)*eta+3.0*(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi+2.0*(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta+3.0*(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi+2.0*(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(162.0-1458.0*xi+2187.0*xi*xi)*eta*eta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta*eta+(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta+(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(162.0-1458.0*xi+2187.0*xi*xi)*eta+3.0*(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi+2.0*(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta+3.0*(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi+2.0*(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (324.0*xi-1458.0*xi*xi+1458.0*xi*xi*xi+6.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta)*zeta+(-810.0*xi+3645.0*xi*xi-3645.0*xi*xi*xi+6.0*(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(486.0*xi-2187.0*xi*xi+2187.0*xi*xi*xi+6.0*(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi+2.0*(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta+3.0*(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(162.0-1458.0*xi+2187.0*xi*xi)*eta*eta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta*eta+(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta+(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi+2.0*(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta+3.0*(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+2.0*(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta*eta+2.0*(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((729.0/2.0-2187.0/2.0*xi)*eta+(-3645.0/4.0+10935.0/4.0*xi)*eta*eta+(2187.0/4.0-6561.0/4.0*xi)*eta*eta*eta)*zeta+((-1458.0+4374.0*xi)*eta+(3645.0-10935.0*xi)*eta*eta+(-2187.0+6561.0*xi)*eta*eta*eta)*zeta*zeta+((2187.0/2.0-6561.0/2.0*xi)*eta+(-10935.0/4.0+32805.0/4.0*xi)*eta*eta+(6561.0/4.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta+(162.0-1458.0*xi+2187.0*xi*xi+2.0*(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta+3.0*(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((162.0-1458.0*xi+2187.0*xi*xi)*eta+(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta*eta+(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi+2.0*(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta+3.0*(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta+(162.0-1458.0*xi+2187.0*xi*xi+2.0*(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta+3.0*(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (405.0/2.0*xi-3645.0/4.0*xi*xi+3645.0/4.0*xi*xi*xi+6.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta+(-810.0*xi+3645.0*xi*xi-3645.0*xi*xi*xi+6.0*(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(1215.0/2.0*xi-10935.0/4.0*xi*xi+10935.0/4.0*xi*xi*xi+6.0*(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi+2.0*(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta+3.0*(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-81.0/2.0+729.0/2.0*xi-2187.0/4.0*xi*xi)*eta+(405.0/4.0-3645.0/4.0*xi+10935.0/8.0*xi*xi)*eta*eta+(-243.0/4.0+2187.0/4.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((162.0-1458.0*xi+2187.0*xi*xi)*eta+(-405.0+3645.0*xi-10935.0/2.0*xi*xi)*eta*eta+(243.0-2187.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-243.0/2.0+2187.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(1215.0/4.0-10935.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-729.0/4.0+6561.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -81.0/2.0*xi+729.0/4.0*xi*xi-729.0/4.0*xi*xi*xi+2.0*(405.0/4.0*xi-3645.0/8.0*xi*xi+3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+2187.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi+2.0*(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta+3.0*(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(162.0*xi-729.0*xi*xi+729.0*xi*xi*xi)*eta+2.0*(-405.0*xi+3645.0/2.0*xi*xi-3645.0/2.0*xi*xi*xi)*eta*eta+2.0*(243.0*xi-2187.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((-243.0/2.0*xi+2187.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(1215.0/4.0*xi-10935.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0*xi+6561.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-729.0/4.0+2187.0/4.0*xi)*eta+(729.0-2187.0*xi)*eta*eta+(-2187.0/4.0+6561.0/4.0*xi)*eta*eta*eta)*zeta+((729.0-2187.0*xi)*eta+(-2916.0+8748.0*xi)*eta*eta+(2187.0-6561.0*xi)*eta*eta*eta)*zeta*zeta+((-2187.0/4.0+6561.0/4.0*xi)*eta+(2187.0-6561.0*xi)*eta*eta+(-6561.0/4.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi+2.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta+(-81.0+729.0*xi-2187.0/2.0*xi*xi+2.0*(324.0-2916.0*xi+4374.0*xi*xi)*eta+3.0*(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi+2.0*(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+(324.0-2916.0*xi+4374.0*xi*xi)*eta*eta+(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi+2.0*(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+3.0*(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta+(-81.0+729.0*xi-2187.0/2.0*xi*xi+2.0*(324.0-2916.0*xi+4374.0*xi*xi)*eta+3.0*(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi+2.0*(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-162.0*xi+729.0*xi*xi-729.0*xi*xi*xi+6.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta+(648.0*xi-2916.0*xi*xi+2916.0*xi*xi*xi+6.0*(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(-486.0*xi+2187.0*xi*xi-2187.0*xi*xi*xi+6.0*(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi+2.0*(324.0*xi-1458.0*xi*xi+1458.0*xi*xi*xi)*eta+3.0*(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (81.0/4.0-729.0/4.0*xi+2187.0/8.0*xi*xi)*eta+(-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta*eta+(243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((-81.0+729.0*xi-2187.0/2.0*xi*xi)*eta+(324.0-2916.0*xi+4374.0*xi*xi)*eta*eta+(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((243.0/4.0-2187.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-243.0+2187.0*xi-6561.0/2.0*xi*xi)*eta*eta+(729.0/4.0-6561.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 81.0/4.0*xi-729.0/8.0*xi*xi+729.0/8.0*xi*xi*xi+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi+2.0*(324.0*xi-1458.0*xi*xi+1458.0*xi*xi*xi)*eta+3.0*(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-81.0*xi+729.0/2.0*xi*xi-729.0/2.0*xi*xi*xi)*eta+2.0*(324.0*xi-1458.0*xi*xi+1458.0*xi*xi*xi)*eta*eta+2.0*(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((243.0/4.0*xi-2187.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-243.0*xi+2187.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(729.0/4.0*xi-6561.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-405.0+729.0*xi)*eta+(2025.0/2.0-3645.0/2.0*xi)*eta*eta+(-1215.0/2.0+2187.0/2.0*xi)*eta*eta*eta)*zeta+((3645.0/2.0-6561.0/2.0*xi)*eta+(-18225.0/4.0+32805.0/4.0*xi)*eta*eta+(10935.0/4.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-3645.0/2.0+6561.0/2.0*xi)*eta+(18225.0/4.0-32805.0/4.0*xi)*eta*eta+(-10935.0/4.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (81.0-405.0*xi+729.0/2.0*xi*xi+2.0*(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta+3.0*(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi+2.0*(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta*eta+(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (81.0-405.0*xi+729.0/2.0*xi*xi+2.0*(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta+3.0*(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta+(-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi+2.0*(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-405.0*xi+2025.0/2.0*xi*xi-1215.0/2.0*xi*xi*xi+6.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta)*zeta+(3645.0/2.0*xi-18225.0/4.0*xi*xi+10935.0/4.0*xi*xi*xi+6.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi+6.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta*eta+(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/2.0-3645.0/2.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/4.0+18225.0/4.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+2.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((729.0/2.0*xi-3645.0/4.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(-3645.0/4.0*xi+18225.0/8.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((324.0-729.0*xi)*eta+(-810.0+3645.0/2.0*xi)*eta*eta+(486.0-2187.0/2.0*xi)*eta*eta*eta)*zeta+((-1458.0+6561.0/2.0*xi)*eta+(3645.0-32805.0/4.0*xi)*eta*eta+(-2187.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((1458.0-6561.0/2.0*xi)*eta+(-3645.0+32805.0/4.0*xi)*eta*eta+(2187.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+2.0*(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta+3.0*(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi+2.0*(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta*eta+(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-81.0/2.0+324.0*xi-729.0/2.0*xi*xi+2.0*(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta+3.0*(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta+(729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi+2.0*(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (405.0/2.0*xi-810.0*xi*xi+1215.0/2.0*xi*xi*xi+6.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta)*zeta+(-3645.0/4.0*xi+3645.0*xi*xi-10935.0/4.0*xi*xi*xi+6.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi+6.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta*eta+(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/4.0+1458.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/8.0-3645.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+2.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-729.0/4.0*xi+729.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(3645.0/8.0*xi-3645.0/2.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((405.0/2.0-729.0/2.0*xi)*eta+(-810.0+1458.0*xi)*eta*eta+(1215.0/2.0-2187.0/2.0*xi)*eta*eta*eta)*zeta+((-3645.0/4.0+6561.0/4.0*xi)*eta+(3645.0-6561.0*xi)*eta*eta+(-10935.0/4.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((3645.0/4.0-6561.0/4.0*xi)*eta+(-3645.0+6561.0*xi)*eta*eta+(10935.0/4.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(162.0-810.0*xi+729.0*xi*xi)*eta+3.0*(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi+2.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi+2.0*(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(162.0-810.0*xi+729.0*xi*xi)*eta*eta+(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(162.0-810.0*xi+729.0*xi*xi)*eta+3.0*(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta)*zeta+(729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi+2.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi+2.0*(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (324.0*xi-810.0*xi*xi+486.0*xi*xi*xi+6.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta)*zeta+(-1458.0*xi+3645.0*xi*xi-2187.0*xi*xi*xi+6.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi+6.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(162.0-810.0*xi+729.0*xi*xi)*eta*eta+(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-729.0/4.0+3645.0/4.0*xi-6561.0/8.0*xi*xi)*eta+(729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta+2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+2.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-729.0/4.0*xi+3645.0/8.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-162.0+729.0/2.0*xi)*eta+(648.0-1458.0*xi)*eta*eta+(-486.0+2187.0/2.0*xi)*eta*eta*eta)*zeta+((729.0-6561.0/4.0*xi)*eta+(-2916.0+6561.0*xi)*eta*eta+(2187.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-729.0+6561.0/4.0*xi)*eta+(2916.0-6561.0*xi)*eta*eta+(-2187.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-81.0+648.0*xi-729.0*xi*xi)*eta+3.0*(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi+2.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi+2.0*(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-81.0+648.0*xi-729.0*xi*xi)*eta*eta+(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (81.0/4.0-162.0*xi+729.0/4.0*xi*xi+2.0*(-81.0+648.0*xi-729.0*xi*xi)*eta+3.0*(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta*eta)*zeta+(-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi+2.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(729.0/8.0-729.0*xi+6561.0/8.0*xi*xi+2.0*(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-162.0*xi+648.0*xi*xi-486.0*xi*xi*xi+6.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta)*zeta+(729.0*xi-2916.0*xi*xi+2187.0*xi*xi*xi+6.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi+6.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-81.0+648.0*xi-729.0*xi*xi)*eta*eta+(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta+2.0*((-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((729.0/8.0-729.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta+2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+2.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((729.0/8.0*xi-729.0/2.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(-729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((1458.0-2187.0*xi)*eta+(-3645.0+10935.0/2.0*xi)*eta*eta+(2187.0-6561.0/2.0*xi)*eta*eta*eta)*zeta+((-3645.0+10935.0/2.0*xi)*eta+(18225.0/2.0-54675.0/4.0*xi)*eta*eta+(-10935.0/2.0+32805.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((2187.0-6561.0/2.0*xi)*eta+(-10935.0/2.0+32805.0/4.0*xi)*eta*eta+(6561.0/2.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi+2.0*(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta+3.0*(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi+2.0*(-22275.0/8.0+18225.0/2.0*xi-54675.0/8.0*xi*xi)*eta+3.0*(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi+2.0*(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta*eta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta+(-22275.0/8.0+18225.0/2.0*xi-54675.0/8.0*xi*xi)*eta*eta+(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta+(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi+2.0*(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta+3.0*(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta)*zeta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi+2.0*(-22275.0/8.0+18225.0/2.0*xi-54675.0/8.0*xi*xi)*eta+3.0*(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi+2.0*(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi+6.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta)*zeta+(2025.0/2.0-22275.0/4.0*xi+18225.0/2.0*xi*xi-18225.0/4.0*xi*xi*xi+6.0*(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-1215.0/2.0+13365.0/4.0*xi-10935.0/2.0*xi*xi+10935.0/4.0*xi*xi*xi+6.0*(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi+2.0*(2025.0/4.0-22275.0/8.0*xi+18225.0/4.0*xi*xi-18225.0/8.0*xi*xi*xi)*eta+3.0*(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-891.0/2.0+1458.0*xi-2187.0/2.0*xi*xi)*eta+(4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta*eta+(-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((4455.0/4.0-3645.0*xi+10935.0/4.0*xi*xi)*eta+(-22275.0/8.0+18225.0/2.0*xi-54675.0/8.0*xi*xi)*eta*eta+(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2673.0/4.0+2187.0*xi-6561.0/4.0*xi*xi)*eta+(13365.0/8.0-10935.0/2.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 81.0-891.0/2.0*xi+729.0*xi*xi-729.0/2.0*xi*xi*xi+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi+2.0*(2025.0/4.0-22275.0/8.0*xi+18225.0/4.0*xi*xi-18225.0/8.0*xi*xi*xi)*eta+3.0*(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-405.0/2.0+4455.0/4.0*xi-3645.0/2.0*xi*xi+3645.0/4.0*xi*xi*xi)*eta+2.0*(2025.0/4.0-22275.0/8.0*xi+18225.0/4.0*xi*xi-18225.0/8.0*xi*xi*xi)*eta*eta+2.0*(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((243.0/2.0-2673.0/4.0*xi+2187.0/2.0*xi*xi-2187.0/4.0*xi*xi*xi)*eta+(-1215.0/4.0+13365.0/8.0*xi-10935.0/4.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta*eta+(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-729.0+2187.0/2.0*xi)*eta+(2916.0-4374.0*xi)*eta*eta+(-2187.0+6561.0/2.0*xi)*eta*eta*eta)*zeta+((3645.0/2.0-10935.0/4.0*xi)*eta+(-7290.0+10935.0*xi)*eta*eta+(10935.0/2.0-32805.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-2187.0/2.0+6561.0/4.0*xi)*eta+(4374.0-6561.0*xi)*eta*eta+(-6561.0/2.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-891.0+2916.0*xi-2187.0*xi*xi)*eta+3.0*(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi+2.0*(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta+3.0*(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi+2.0*(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-891.0+2916.0*xi-2187.0*xi*xi)*eta*eta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta*eta+(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta+(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta*eta+(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-891.0+2916.0*xi-2187.0*xi*xi)*eta+3.0*(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta)*zeta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi+2.0*(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta+3.0*(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi+2.0*(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (324.0-1782.0*xi+2916.0*xi*xi-1458.0*xi*xi*xi+6.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta)*zeta+(-810.0+4455.0*xi-7290.0*xi*xi+3645.0*xi*xi*xi+6.0*(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(486.0-2673.0*xi+4374.0*xi*xi-2187.0*xi*xi*xi+6.0*(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi+2.0*(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta+3.0*(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-891.0+2916.0*xi-2187.0*xi*xi)*eta*eta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta*eta*eta+2.0*((-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta*eta+(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta+(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta*eta+(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+3.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta*eta+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi+2.0*(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta+3.0*(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+2.0*(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta*eta+2.0*(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta+(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta+(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-729.0+2187.0/2.0*xi)*eta+(3645.0/2.0-10935.0/4.0*xi)*eta*eta+(-2187.0/2.0+6561.0/4.0*xi)*eta*eta*eta)*zeta+((2916.0-4374.0*xi)*eta+(-7290.0+10935.0*xi)*eta*eta+(4374.0-6561.0*xi)*eta*eta*eta)*zeta*zeta+((-2187.0+6561.0/2.0*xi)*eta+(10935.0/2.0-32805.0/4.0*xi)*eta*eta+(-6561.0/2.0+19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta+(-891.0+2916.0*xi-2187.0*xi*xi+2.0*(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta+3.0*(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi+2.0*(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((-891.0+2916.0*xi-2187.0*xi*xi)*eta+(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta*eta+(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta+(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta*eta+(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (891.0/4.0-729.0*xi+2187.0/4.0*xi*xi+2.0*(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta+3.0*(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta)*zeta+(-891.0+2916.0*xi-2187.0*xi*xi+2.0*(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta+3.0*(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi+2.0*(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (405.0/2.0-4455.0/4.0*xi+3645.0/2.0*xi*xi-3645.0/4.0*xi*xi*xi+6.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta)*zeta+(-810.0+4455.0*xi-7290.0*xi*xi+3645.0*xi*xi*xi+6.0*(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(1215.0/2.0-13365.0/4.0*xi+10935.0/2.0*xi*xi-10935.0/4.0*xi*xi*xi+6.0*(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi+2.0*(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta+3.0*(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (891.0/4.0-729.0*xi+2187.0/4.0*xi*xi)*eta+(-4455.0/8.0+3645.0/2.0*xi-10935.0/8.0*xi*xi)*eta*eta+(2673.0/8.0-2187.0/2.0*xi+6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((-891.0+2916.0*xi-2187.0*xi*xi)*eta+(4455.0/2.0-7290.0*xi+10935.0/2.0*xi*xi)*eta*eta+(-2673.0/2.0+4374.0*xi-6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2673.0/4.0-2187.0*xi+6561.0/4.0*xi*xi)*eta+(-13365.0/8.0+10935.0/2.0*xi-32805.0/8.0*xi*xi)*eta*eta+(8019.0/8.0-6561.0/2.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -81.0/2.0+891.0/4.0*xi-729.0/2.0*xi*xi+729.0/4.0*xi*xi*xi+2.0*(405.0/4.0-4455.0/8.0*xi+3645.0/4.0*xi*xi-3645.0/8.0*xi*xi*xi)*eta+3.0*(-243.0/4.0+2673.0/8.0*xi-2187.0/4.0*xi*xi+2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi+2.0*(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta+3.0*(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(162.0-891.0*xi+1458.0*xi*xi-729.0*xi*xi*xi)*eta+2.0*(-405.0+4455.0/2.0*xi-3645.0*xi*xi+3645.0/2.0*xi*xi*xi)*eta*eta+2.0*(243.0-2673.0/2.0*xi+2187.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((-243.0/2.0+2673.0/4.0*xi-2187.0/2.0*xi*xi+2187.0/4.0*xi*xi*xi)*eta+(1215.0/4.0-13365.0/8.0*xi+10935.0/4.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta*eta+(-729.0/4.0+8019.0/8.0*xi-6561.0/4.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((729.0/2.0-2187.0/4.0*xi)*eta+(-1458.0+2187.0*xi)*eta*eta+(2187.0/2.0-6561.0/4.0*xi)*eta*eta*eta)*zeta+((-1458.0+2187.0*xi)*eta+(5832.0-8748.0*xi)*eta*eta+(-4374.0+6561.0*xi)*eta*eta*eta)*zeta*zeta+((2187.0/2.0-6561.0/4.0*xi)*eta+(-4374.0+6561.0*xi)*eta*eta+(6561.0/2.0-19683.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi+2.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi+2.0*(-1782.0+5832.0*xi-4374.0*xi*xi)*eta+3.0*(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi+2.0*(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+(-1782.0+5832.0*xi-4374.0*xi*xi)*eta*eta+(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta+(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi+2.0*(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+3.0*(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta)*zeta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi+2.0*(-1782.0+5832.0*xi-4374.0*xi*xi)*eta+3.0*(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi+2.0*(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-162.0+891.0*xi-1458.0*xi*xi+729.0*xi*xi*xi+6.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta)*zeta+(648.0-3564.0*xi+5832.0*xi*xi-2916.0*xi*xi*xi+6.0*(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(-486.0+2673.0*xi-4374.0*xi*xi+2187.0*xi*xi*xi+6.0*(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi+2.0*(324.0-1782.0*xi+2916.0*xi*xi-1458.0*xi*xi*xi)*eta+3.0*(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-891.0/8.0+729.0/2.0*xi-2187.0/8.0*xi*xi)*eta+(891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta*eta+(-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta*eta*eta+2.0*((891.0/2.0-1458.0*xi+2187.0/2.0*xi*xi)*eta+(-1782.0+5832.0*xi-4374.0*xi*xi)*eta*eta+(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2673.0/8.0+2187.0/2.0*xi-6561.0/8.0*xi*xi)*eta+(2673.0/2.0-4374.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-8019.0/8.0+6561.0/2.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 81.0/4.0-891.0/8.0*xi+729.0/4.0*xi*xi-729.0/8.0*xi*xi*xi+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta*eta+2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi+2.0*(324.0-1782.0*xi+2916.0*xi*xi-1458.0*xi*xi*xi)*eta+3.0*(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-81.0+891.0/2.0*xi-729.0*xi*xi+729.0/2.0*xi*xi*xi)*eta+2.0*(324.0-1782.0*xi+2916.0*xi*xi-1458.0*xi*xi*xi)*eta*eta+2.0*(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((243.0/4.0-2673.0/8.0*xi+2187.0/4.0*xi*xi-2187.0/8.0*xi*xi*xi)*eta+(-243.0+2673.0/2.0*xi-2187.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta*eta+(729.0/4.0-8019.0/8.0*xi+6561.0/4.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-3645.0+6561.0*xi)*eta+(18225.0/2.0-32805.0/2.0*xi)*eta*eta+(-10935.0/2.0+19683.0/2.0*xi)*eta*eta*eta)*zeta+((18225.0/2.0-32805.0/2.0*xi)*eta+(-91125.0/4.0+164025.0/4.0*xi)*eta*eta+(54675.0/4.0-98415.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-10935.0/2.0+19683.0/2.0*xi)*eta+(54675.0/4.0-98415.0/4.0*xi)*eta*eta+(-32805.0/4.0+59049.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (729.0-3645.0*xi+6561.0/2.0*xi*xi+2.0*(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta+3.0*(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta)*zeta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi+2.0*(18225.0/4.0-91125.0/4.0*xi+164025.0/8.0*xi*xi)*eta+3.0*(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi+2.0*(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta+3.0*(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta*eta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta+2.0*((-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta+(18225.0/4.0-91125.0/4.0*xi+164025.0/8.0*xi*xi)*eta*eta+(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta+(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta*eta+(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (729.0-3645.0*xi+6561.0/2.0*xi*xi+2.0*(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta+3.0*(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta)*zeta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi+2.0*(18225.0/4.0-91125.0/4.0*xi+164025.0/8.0*xi*xi)*eta+3.0*(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi+2.0*(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta+3.0*(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi+6.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta)*zeta+(18225.0/2.0*xi-91125.0/4.0*xi*xi+54675.0/4.0*xi*xi*xi+6.0*(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-10935.0/2.0*xi+54675.0/4.0*xi*xi-32805.0/4.0*xi*xi*xi+6.0*(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi+2.0*(18225.0/4.0*xi-91125.0/8.0*xi*xi+54675.0/8.0*xi*xi*xi)*eta+3.0*(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi+2.0*(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta+3.0*(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (729.0-3645.0*xi+6561.0/2.0*xi*xi)*eta+(-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta*eta+(2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta+2.0*((-3645.0/2.0+18225.0/2.0*xi-32805.0/4.0*xi*xi)*eta+(18225.0/4.0-91125.0/4.0*xi+164025.0/8.0*xi*xi)*eta*eta+(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/2.0-10935.0/2.0*xi+19683.0/4.0*xi*xi)*eta+(-10935.0/4.0+54675.0/4.0*xi-98415.0/8.0*xi*xi)*eta*eta+(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 729.0*xi-3645.0/2.0*xi*xi+2187.0/2.0*xi*xi*xi+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+3.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi+2.0*(18225.0/4.0*xi-91125.0/8.0*xi*xi+54675.0/8.0*xi*xi*xi)*eta+3.0*(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi+2.0*(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta+3.0*(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-3645.0/2.0*xi+18225.0/4.0*xi*xi-10935.0/4.0*xi*xi*xi)*eta+2.0*(18225.0/4.0*xi-91125.0/8.0*xi*xi+54675.0/8.0*xi*xi*xi)*eta*eta+2.0*(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((2187.0/2.0*xi-10935.0/4.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+(-10935.0/4.0*xi+54675.0/8.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta+(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((2916.0-6561.0*xi)*eta+(-7290.0+32805.0/2.0*xi)*eta*eta+(4374.0-19683.0/2.0*xi)*eta*eta*eta)*zeta+((-7290.0+32805.0/2.0*xi)*eta+(18225.0-164025.0/4.0*xi)*eta*eta+(-10935.0+98415.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((4374.0-19683.0/2.0*xi)*eta+(-10935.0+98415.0/4.0*xi)*eta*eta+(6561.0-59049.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi+2.0*(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta+3.0*(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta)*zeta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi+2.0*(-18225.0/8.0+18225.0*xi-164025.0/8.0*xi*xi)*eta+3.0*(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi+2.0*(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta+3.0*(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta*eta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta+2.0*((3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta+(-18225.0/8.0+18225.0*xi-164025.0/8.0*xi*xi)*eta*eta+(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta+(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta*eta+(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi+2.0*(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta+3.0*(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta)*zeta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi+2.0*(-18225.0/8.0+18225.0*xi-164025.0/8.0*xi*xi)*eta+3.0*(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi+2.0*(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta+3.0*(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi+6.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta)*zeta+(-18225.0/4.0*xi+18225.0*xi*xi-54675.0/4.0*xi*xi*xi+6.0*(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(10935.0/4.0*xi-10935.0*xi*xi+32805.0/4.0*xi*xi*xi+6.0*(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi+2.0*(-18225.0/8.0*xi+18225.0/2.0*xi*xi-54675.0/8.0*xi*xi*xi)*eta+3.0*(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi+2.0*(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta+3.0*(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-729.0/2.0+2916.0*xi-6561.0/2.0*xi*xi)*eta+(3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta*eta+(-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta+2.0*((3645.0/4.0-7290.0*xi+32805.0/4.0*xi*xi)*eta+(-18225.0/8.0+18225.0*xi-164025.0/8.0*xi*xi)*eta*eta+(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/4.0+4374.0*xi-19683.0/4.0*xi*xi)*eta+(10935.0/8.0-10935.0*xi+98415.0/8.0*xi*xi)*eta*eta+(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -729.0/2.0*xi+1458.0*xi*xi-2187.0/2.0*xi*xi*xi+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta+2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi+2.0*(-18225.0/8.0*xi+18225.0/2.0*xi*xi-54675.0/8.0*xi*xi*xi)*eta+3.0*(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi+2.0*(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta+3.0*(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(3645.0/4.0*xi-3645.0*xi*xi+10935.0/4.0*xi*xi*xi)*eta+2.0*(-18225.0/8.0*xi+18225.0/2.0*xi*xi-54675.0/8.0*xi*xi*xi)*eta*eta+2.0*(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-2187.0/4.0*xi+2187.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+(10935.0/8.0*xi-10935.0/2.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta+(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((3645.0/2.0-6561.0/2.0*xi)*eta+(-7290.0+13122.0*xi)*eta*eta+(10935.0/2.0-19683.0/2.0*xi)*eta*eta*eta)*zeta+((-18225.0/4.0+32805.0/4.0*xi)*eta+(18225.0-32805.0*xi)*eta*eta+(-54675.0/4.0+98415.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((10935.0/4.0-19683.0/4.0*xi)*eta+(-10935.0+19683.0*xi)*eta*eta+(32805.0/4.0-59049.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(1458.0-7290.0*xi+6561.0*xi*xi)*eta+3.0*(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta)*zeta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi+2.0*(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta+3.0*(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi+2.0*(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta+3.0*(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(1458.0-7290.0*xi+6561.0*xi*xi)*eta*eta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta+2.0*((3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta*eta+(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta+(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta*eta+(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(1458.0-7290.0*xi+6561.0*xi*xi)*eta+3.0*(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta)*zeta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi+2.0*(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta+3.0*(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi+2.0*(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta+3.0*(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (2916.0*xi-7290.0*xi*xi+4374.0*xi*xi*xi+6.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta)*zeta+(-7290.0*xi+18225.0*xi*xi-10935.0*xi*xi*xi+6.0*(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(4374.0*xi-10935.0*xi*xi+6561.0*xi*xi*xi+6.0*(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+3.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi+2.0*(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta+3.0*(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi+2.0*(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta+3.0*(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(1458.0-7290.0*xi+6561.0*xi*xi)*eta*eta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta*eta*eta+2.0*((3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta*eta+(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta+(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta*eta+(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+3.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta*eta+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi+2.0*(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta+3.0*(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi+2.0*(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta+3.0*(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+2.0*(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta*eta+2.0*(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta+(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-1458.0+6561.0/2.0*xi)*eta+(5832.0-13122.0*xi)*eta*eta+(-4374.0+19683.0/2.0*xi)*eta*eta*eta)*zeta+((3645.0-32805.0/4.0*xi)*eta+(-14580.0+32805.0*xi)*eta*eta+(10935.0-98415.0/4.0*xi)*eta*eta*eta)*zeta*zeta+((-2187.0+19683.0/4.0*xi)*eta+(8748.0-19683.0*xi)*eta*eta+(-6561.0+59049.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-729.0+5832.0*xi-6561.0*xi*xi)*eta+3.0*(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta)*zeta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi+2.0*(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta+3.0*(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi+2.0*(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta+3.0*(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-729.0+5832.0*xi-6561.0*xi*xi)*eta*eta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta+2.0*((-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta*eta+(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta+(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta*eta+(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-729.0+5832.0*xi-6561.0*xi*xi)*eta+3.0*(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta)*zeta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi+2.0*(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta+3.0*(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta*eta)*zeta*zeta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi+2.0*(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta+3.0*(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-1458.0*xi+5832.0*xi*xi-4374.0*xi*xi*xi+6.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta)*zeta+(3645.0*xi-14580.0*xi*xi+10935.0*xi*xi*xi+6.0*(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta)*zeta*zeta+(-2187.0*xi+8748.0*xi*xi-6561.0*xi*xi*xi+6.0*(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi+2.0*(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta+3.0*(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi+2.0*(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta+3.0*(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-729.0+5832.0*xi-6561.0*xi*xi)*eta*eta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta*eta*eta+2.0*((-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta*eta+(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta+(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta*eta+(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta*eta+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi+2.0*(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta+3.0*(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi+2.0*(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta+3.0*(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+2.0*(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta*eta+2.0*(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta*eta+6.0*((2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta+(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((3645.0/2.0-6561.0/2.0*xi)*eta+(-18225.0/4.0+32805.0/4.0*xi)*eta*eta+(10935.0/4.0-19683.0/4.0*xi)*eta*eta*eta)*zeta+((-7290.0+13122.0*xi)*eta+(18225.0-32805.0*xi)*eta*eta+(-10935.0+19683.0*xi)*eta*eta*eta)*zeta*zeta+((10935.0/2.0-19683.0/2.0*xi)*eta+(-54675.0/4.0+98415.0/4.0*xi)*eta*eta+(32805.0/4.0-59049.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta+(1458.0-7290.0*xi+6561.0*xi*xi+2.0*(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta+3.0*(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi+2.0*(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta+3.0*(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta+2.0*((1458.0-7290.0*xi+6561.0*xi*xi)*eta+(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta*eta+(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta+(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta*eta+(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi+2.0*(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta+3.0*(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta+(1458.0-7290.0*xi+6561.0*xi*xi+2.0*(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta+3.0*(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi+2.0*(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta+3.0*(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (3645.0/2.0*xi-18225.0/4.0*xi*xi+10935.0/4.0*xi*xi*xi+6.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta+(-7290.0*xi+18225.0*xi*xi-10935.0*xi*xi*xi+6.0*(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(10935.0/2.0*xi-54675.0/4.0*xi*xi+32805.0/4.0*xi*xi*xi+6.0*(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi+2.0*(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta+3.0*(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi+2.0*(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta+3.0*(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-729.0/2.0+3645.0/2.0*xi-6561.0/4.0*xi*xi)*eta+(3645.0/4.0-18225.0/4.0*xi+32805.0/8.0*xi*xi)*eta*eta+(-2187.0/4.0+10935.0/4.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta+2.0*((1458.0-7290.0*xi+6561.0*xi*xi)*eta+(-3645.0+18225.0*xi-32805.0/2.0*xi*xi)*eta*eta+(2187.0-10935.0*xi+19683.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/2.0+10935.0/2.0*xi-19683.0/4.0*xi*xi)*eta+(10935.0/4.0-54675.0/4.0*xi+98415.0/8.0*xi*xi)*eta*eta+(-6561.0/4.0+32805.0/4.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -729.0/2.0*xi+3645.0/4.0*xi*xi-2187.0/4.0*xi*xi*xi+2.0*(3645.0/4.0*xi-18225.0/8.0*xi*xi+10935.0/8.0*xi*xi*xi)*eta+3.0*(-2187.0/4.0*xi+10935.0/8.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta+2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi+2.0*(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta+3.0*(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi+2.0*(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta+3.0*(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(1458.0*xi-3645.0*xi*xi+2187.0*xi*xi*xi)*eta+2.0*(-3645.0*xi+18225.0/2.0*xi*xi-10935.0/2.0*xi*xi*xi)*eta*eta+2.0*(2187.0*xi-10935.0/2.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((-2187.0/2.0*xi+10935.0/4.0*xi*xi-6561.0/4.0*xi*xi*xi)*eta+(10935.0/4.0*xi-54675.0/8.0*xi*xi+32805.0/8.0*xi*xi*xi)*eta*eta+(-6561.0/4.0*xi+32805.0/8.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-1458.0+6561.0/2.0*xi)*eta+(3645.0-32805.0/4.0*xi)*eta*eta+(-2187.0+19683.0/4.0*xi)*eta*eta*eta)*zeta+((5832.0-13122.0*xi)*eta+(-14580.0+32805.0*xi)*eta*eta+(8748.0-19683.0*xi)*eta*eta*eta)*zeta*zeta+((-4374.0+19683.0/2.0*xi)*eta+(10935.0-98415.0/4.0*xi)*eta*eta+(-6561.0+59049.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta+(-729.0+5832.0*xi-6561.0*xi*xi+2.0*(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta+3.0*(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi+2.0*(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta+3.0*(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta+2.0*((-729.0+5832.0*xi-6561.0*xi*xi)*eta+(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta*eta+(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta+(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta*eta+(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi+2.0*(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta+3.0*(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta+(-729.0+5832.0*xi-6561.0*xi*xi+2.0*(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta+3.0*(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi+2.0*(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta+3.0*(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-3645.0/4.0*xi+3645.0*xi*xi-10935.0/4.0*xi*xi*xi+6.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta+(3645.0*xi-14580.0*xi*xi+10935.0*xi*xi*xi+6.0*(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(-10935.0/4.0*xi+10935.0*xi*xi-32805.0/4.0*xi*xi*xi+6.0*(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi+2.0*(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi+2.0*(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta+3.0*(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (729.0/4.0-1458.0*xi+6561.0/4.0*xi*xi)*eta+(-3645.0/8.0+3645.0*xi-32805.0/8.0*xi*xi)*eta*eta+(2187.0/8.0-2187.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta+2.0*((-729.0+5832.0*xi-6561.0*xi*xi)*eta+(3645.0/2.0-14580.0*xi+32805.0/2.0*xi*xi)*eta*eta+(-2187.0/2.0+8748.0*xi-19683.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/4.0-4374.0*xi+19683.0/4.0*xi*xi)*eta+(-10935.0/8.0+10935.0*xi-98415.0/8.0*xi*xi)*eta*eta+(6561.0/8.0-6561.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 729.0/4.0*xi-729.0*xi*xi+2187.0/4.0*xi*xi*xi+2.0*(-3645.0/8.0*xi+3645.0/2.0*xi*xi-10935.0/8.0*xi*xi*xi)*eta+3.0*(2187.0/8.0*xi-2187.0/2.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta+2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi+2.0*(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi+2.0*(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta+3.0*(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-729.0*xi+2916.0*xi*xi-2187.0*xi*xi*xi)*eta+2.0*(3645.0/2.0*xi-7290.0*xi*xi+10935.0/2.0*xi*xi*xi)*eta*eta+2.0*(-2187.0/2.0*xi+4374.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((2187.0/4.0*xi-2187.0*xi*xi+6561.0/4.0*xi*xi*xi)*eta+(-10935.0/8.0*xi+10935.0/2.0*xi*xi-32805.0/8.0*xi*xi*xi)*eta*eta+(6561.0/8.0*xi-6561.0/2.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((-3645.0/4.0+6561.0/4.0*xi)*eta+(3645.0-6561.0*xi)*eta*eta+(-10935.0/4.0+19683.0/4.0*xi)*eta*eta*eta)*zeta+((3645.0-6561.0*xi)*eta+(-14580.0+26244.0*xi)*eta*eta+(10935.0-19683.0*xi)*eta*eta*eta)*zeta*zeta+((-10935.0/4.0+19683.0/4.0*xi)*eta+(10935.0-19683.0*xi)*eta*eta+(-32805.0/4.0+59049.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi+2.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi+2.0*(2916.0-14580.0*xi+13122.0*xi*xi)*eta+3.0*(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi+2.0*(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta+3.0*(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta+2.0*((-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+(2916.0-14580.0*xi+13122.0*xi*xi)*eta*eta+(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta+(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta*eta+(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi+2.0*(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+3.0*(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta)*zeta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi+2.0*(2916.0-14580.0*xi+13122.0*xi*xi)*eta+3.0*(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi+2.0*(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta+3.0*(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (-1458.0*xi+3645.0*xi*xi-2187.0*xi*xi*xi+6.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta)*zeta+(5832.0*xi-14580.0*xi*xi+8748.0*xi*xi*xi+6.0*(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(-4374.0*xi+10935.0*xi*xi-6561.0*xi*xi*xi+6.0*(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = 729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi+2.0*(2916.0*xi-7290.0*xi*xi+4374.0*xi*xi*xi)*eta+3.0*(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi+2.0*(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta+3.0*(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (729.0/4.0-3645.0/4.0*xi+6561.0/8.0*xi*xi)*eta+(-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta*eta+(2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta*eta*eta+2.0*((-729.0+3645.0*xi-6561.0/2.0*xi*xi)*eta+(2916.0-14580.0*xi+13122.0*xi*xi)*eta*eta+(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((2187.0/4.0-10935.0/4.0*xi+19683.0/8.0*xi*xi)*eta+(-2187.0+10935.0*xi-19683.0/2.0*xi*xi)*eta*eta+(6561.0/4.0-32805.0/4.0*xi+59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = 729.0/4.0*xi-3645.0/8.0*xi*xi+2187.0/8.0*xi*xi*xi+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta*eta+2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi+2.0*(2916.0*xi-7290.0*xi*xi+4374.0*xi*xi*xi)*eta+3.0*(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi+2.0*(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta+3.0*(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(-729.0*xi+3645.0/2.0*xi*xi-2187.0/2.0*xi*xi*xi)*eta+2.0*(2916.0*xi-7290.0*xi*xi+4374.0*xi*xi*xi)*eta*eta+2.0*(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((2187.0/4.0*xi-10935.0/8.0*xi*xi+6561.0/8.0*xi*xi*xi)*eta+(-2187.0*xi+10935.0/2.0*xi*xi-6561.0/2.0*xi*xi*xi)*eta*eta+(6561.0/4.0*xi-32805.0/8.0*xi*xi+19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+return_value[0][0] = ((729.0-6561.0/4.0*xi)*eta+(-2916.0+6561.0*xi)*eta*eta+(2187.0-19683.0/4.0*xi)*eta*eta*eta)*zeta+((-2916.0+6561.0*xi)*eta+(11664.0-26244.0*xi)*eta*eta+(-8748.0+19683.0*xi)*eta*eta*eta)*zeta*zeta+((2187.0-19683.0/4.0*xi)*eta+(-8748.0+19683.0*xi)*eta*eta+(6561.0-59049.0/4.0*xi)*eta*eta*eta)*zeta*zeta*zeta;
+return_value[0][1] = (-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi+2.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi+2.0*(-1458.0+11664.0*xi-13122.0*xi*xi)*eta+3.0*(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi+2.0*(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta+3.0*(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[0][2] = (-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta+2.0*((729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+(-1458.0+11664.0*xi-13122.0*xi*xi)*eta*eta+(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta+(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta*eta+(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[1][0] = (-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi+2.0*(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+3.0*(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta)*zeta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi+2.0*(-1458.0+11664.0*xi-13122.0*xi*xi)*eta+3.0*(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta*eta)*zeta*zeta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi+2.0*(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta+3.0*(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta)*zeta*zeta*zeta;
+return_value[1][1] = (729.0*xi-2916.0*xi*xi+2187.0*xi*xi*xi+6.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta)*zeta+(-2916.0*xi+11664.0*xi*xi-8748.0*xi*xi*xi+6.0*(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta)*zeta*zeta+(2187.0*xi-8748.0*xi*xi+6561.0*xi*xi*xi+6.0*(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta)*zeta*zeta*zeta;
+return_value[1][2] = -729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi+2.0*(-1458.0*xi+5832.0*xi*xi-4374.0*xi*xi*xi)*eta+3.0*(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi+2.0*(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta+3.0*(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][0] = (-729.0/8.0+729.0*xi-6561.0/8.0*xi*xi)*eta+(729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta*eta+(-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta*eta*eta+2.0*((729.0/2.0-2916.0*xi+6561.0/2.0*xi*xi)*eta+(-1458.0+11664.0*xi-13122.0*xi*xi)*eta*eta+(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta*eta*eta)*zeta+3.0*((-2187.0/8.0+2187.0*xi-19683.0/8.0*xi*xi)*eta+(2187.0/2.0-8748.0*xi+19683.0/2.0*xi*xi)*eta*eta+(-6561.0/8.0+6561.0*xi-59049.0/8.0*xi*xi)*eta*eta*eta)*zeta*zeta;
+return_value[2][1] = -729.0/8.0*xi+729.0/2.0*xi*xi-2187.0/8.0*xi*xi*xi+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta*eta+2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi+2.0*(-1458.0*xi+5832.0*xi*xi-4374.0*xi*xi*xi)*eta+3.0*(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta)*zeta+3.0*(-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi+2.0*(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta+3.0*(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta)*zeta*zeta;
+return_value[2][2] = 2.0*(729.0/2.0*xi-1458.0*xi*xi+2187.0/2.0*xi*xi*xi)*eta+2.0*(-1458.0*xi+5832.0*xi*xi-4374.0*xi*xi*xi)*eta*eta+2.0*(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta*eta+6.0*((-2187.0/8.0*xi+2187.0/2.0*xi*xi-6561.0/8.0*xi*xi*xi)*eta+(2187.0/2.0*xi-4374.0*xi*xi+6561.0/2.0*xi*xi*xi)*eta*eta+(-6561.0/8.0*xi+6561.0/2.0*xi*xi-19683.0/8.0*xi*xi*xi)*eta*eta*eta)*zeta;
+      break;
+    };
+  return return_value;
+};
+
+
+
+template <>
+void FECubicSub<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
+                                              const Boundary<3> &,
+                                              dFMatrix &local_mass_matrix) const {
+  Assert (local_mass_matrix.n() == total_dofs,
+         ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
+  Assert (local_mass_matrix.m() == total_dofs,
+         ExcWrongFieldDimension(local_mass_matrix.m(),total_dofs));
+
+  AssertThrow (false, ExcComputationNotUseful(3));
+};
+
+
+
+template <>
+void FECubicSub<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
+  Assert (unit_points.size() == total_dofs,
+         ExcWrongFieldDimension (unit_points.size(), total_dofs));
+  unit_points[0] = Point<3>(0, 0, 0);
+  unit_points[1] = Point<3>(1, 0, 0);
+  unit_points[2] = Point<3>(1, 0, 1);
+  unit_points[3] = Point<3>(0, 0, 1);
+  unit_points[4] = Point<3>(0, 1, 0);
+  unit_points[5] = Point<3>(1, 1, 0);
+  unit_points[6] = Point<3>(1, 1, 1);
+  unit_points[7] = Point<3>(0, 1, 1);
+  unit_points[8] = Point<3>(1/3, 0, 0);
+  unit_points[9] = Point<3>(2/3, 0, 0);
+  unit_points[10] = Point<3>(1, 0, 1/3);
+  unit_points[11] = Point<3>(1, 0, 2/3);
+  unit_points[12] = Point<3>(1/3, 0, 1);
+  unit_points[13] = Point<3>(2/3, 0, 1);
+  unit_points[14] = Point<3>(0, 0, 1/3);
+  unit_points[15] = Point<3>(0, 0, 2/3);
+  unit_points[16] = Point<3>(1/3, 1, 0);
+  unit_points[17] = Point<3>(2/3, 1, 0);
+  unit_points[18] = Point<3>(1, 1, 1/3);
+  unit_points[19] = Point<3>(1, 1, 2/3);
+  unit_points[20] = Point<3>(1/3, 1, 1);
+  unit_points[21] = Point<3>(2/3, 1, 1);
+  unit_points[22] = Point<3>(0, 1, 1/3);
+  unit_points[23] = Point<3>(0, 1, 2/3);
+  unit_points[24] = Point<3>(0, 1/3, 0);
+  unit_points[25] = Point<3>(0, 2/3, 0);
+  unit_points[26] = Point<3>(1, 1/3, 0);
+  unit_points[27] = Point<3>(1, 2/3, 0);
+  unit_points[28] = Point<3>(1, 1/3, 1);
+  unit_points[29] = Point<3>(1, 2/3, 1);
+  unit_points[30] = Point<3>(0, 1/3, 1);
+  unit_points[31] = Point<3>(0, 2/3, 1);
+  unit_points[32] = Point<3>(1/3, 0, 1/3);
+  unit_points[33] = Point<3>(2/3, 0, 1/3);
+  unit_points[34] = Point<3>(1/3, 0, 2/3);
+  unit_points[35] = Point<3>(2/3, 0, 2/3);
+  unit_points[36] = Point<3>(1/3, 1, 1/3);
+  unit_points[37] = Point<3>(2/3, 1, 1/3);
+  unit_points[38] = Point<3>(1/3, 1, 2/3);
+  unit_points[39] = Point<3>(2/3, 1, 2/3);
+  unit_points[40] = Point<3>(1/3, 1/3, 0);
+  unit_points[41] = Point<3>(2/3, 1/3, 0);
+  unit_points[42] = Point<3>(1/3, 2/3, 0);
+  unit_points[43] = Point<3>(2/3, 2/3, 0);
+  unit_points[44] = Point<3>(1, 1/3, 1/3);
+  unit_points[45] = Point<3>(1, 2/3, 1/3);
+  unit_points[46] = Point<3>(1, 1/3, 2/3);
+  unit_points[47] = Point<3>(1, 2/3, 2/3);
+  unit_points[48] = Point<3>(1/3, 1/3, 1);
+  unit_points[49] = Point<3>(2/3, 1/3, 1);
+  unit_points[50] = Point<3>(1/3, 2/3, 1);
+  unit_points[51] = Point<3>(2/3, 2/3, 1);
+  unit_points[52] = Point<3>(0, 1/3, 1/3);
+  unit_points[53] = Point<3>(0, 2/3, 1/3);
+  unit_points[54] = Point<3>(0, 1/3, 2/3);
+  unit_points[55] = Point<3>(0, 2/3, 2/3);
+  unit_points[56] = Point<3>(1/3, 1/3, 1/3);
+  unit_points[57] = Point<3>(2/3, 1/3, 1/3);
+  unit_points[58] = Point<3>(1/3, 2/3, 1/3);
+  unit_points[59] = Point<3>(2/3, 2/3, 1/3);
+  unit_points[60] = Point<3>(1/3, 1/3, 2/3);
+  unit_points[61] = Point<3>(2/3, 1/3, 2/3);
+  unit_points[62] = Point<3>(1/3, 2/3, 2/3);
+  unit_points[63] = Point<3>(2/3, 2/3, 2/3);
+};
+
+
+
+template <>
+void FECubicSub<3>::get_support_points (const typename DoFHandler<3>::cell_iterator &cell,
+                                          const Boundary<3>&,
+                                          vector<Point<3> >  &support_points) const {
+  Assert (support_points.size() == total_dofs,
+         ExcWrongFieldDimension (support_points.size(), total_dofs));
+
+  const Point<3> vertices[8] = { cell->vertex(0),
+                                cell->vertex(1),
+                                cell->vertex(2),
+                                cell->vertex(3),
+                                cell->vertex(4),
+                                cell->vertex(5),
+                                cell->vertex(6),
+                                cell->vertex(7)  };
+  const double t1 = 2.0/3.0*vertices[0](0);
+  const double t2 = vertices[1](0)/3.0;
+  const double t4 = 2.0/3.0*vertices[0](1);
+  const double t5 = vertices[1](1)/3.0;
+  const double t7 = 2.0/3.0*vertices[0](2);
+  const double t8 = vertices[1](2)/3.0;
+  const double t10 = vertices[0](0)/3.0;
+  const double t11 = 2.0/3.0*vertices[1](0);
+  const double t13 = vertices[0](1)/3.0;
+  const double t14 = 2.0/3.0*vertices[1](1);
+  const double t16 = vertices[0](2)/3.0;
+  const double t17 = 2.0/3.0*vertices[1](2);
+  const double t19 = vertices[2](0)/3.0;
+  const double t21 = vertices[2](1)/3.0;
+  const double t23 = vertices[2](2)/3.0;
+  const double t25 = 2.0/3.0*vertices[2](0);
+  const double t27 = 2.0/3.0*vertices[2](1);
+  const double t29 = 2.0/3.0*vertices[2](2);
+  const double t31 = 2.0/3.0*vertices[3](0);
+  const double t33 = 2.0/3.0*vertices[3](1);
+  const double t35 = 2.0/3.0*vertices[3](2);
+  const double t37 = vertices[3](0)/3.0;
+  const double t39 = vertices[3](1)/3.0;
+  const double t41 = vertices[3](2)/3.0;
+  const double t49 = 2.0/3.0*vertices[4](0);
+  const double t50 = vertices[5](0)/3.0;
+  const double t52 = 2.0/3.0*vertices[4](1);
+  const double t53 = vertices[5](1)/3.0;
+  const double t55 = 2.0/3.0*vertices[4](2);
+  const double t56 = vertices[5](2)/3.0;
+  const double t58 = vertices[4](0)/3.0;
+  const double t59 = 2.0/3.0*vertices[5](0);
+  const double t61 = vertices[4](1)/3.0;
+  const double t62 = 2.0/3.0*vertices[5](1);
+  const double t64 = vertices[4](2)/3.0;
+  const double t65 = 2.0/3.0*vertices[5](2);
+  const double t67 = vertices[6](0)/3.0;
+  const double t69 = vertices[6](1)/3.0;
+  const double t71 = vertices[6](2)/3.0;
+  const double t73 = 2.0/3.0*vertices[6](0);
+  const double t75 = 2.0/3.0*vertices[6](1);
+  const double t77 = 2.0/3.0*vertices[6](2);
+  const double t79 = 2.0/3.0*vertices[7](0);
+  const double t81 = 2.0/3.0*vertices[7](1);
+  const double t83 = 2.0/3.0*vertices[7](2);
+  const double t85 = vertices[7](0)/3.0;
+  const double t87 = vertices[7](1)/3.0;
+  const double t89 = vertices[7](2)/3.0;
+  const double t121 = 4.0/9.0*vertices[0](0);
+  const double t122 = 2.0/9.0*vertices[1](0);
+  const double t123 = vertices[2](0)/9.0;
+  const double t124 = 2.0/9.0*vertices[3](0);
+  const double t126 = 4.0/9.0*vertices[0](1);
+  const double t127 = 2.0/9.0*vertices[1](1);
+  const double t128 = vertices[2](1)/9.0;
+  const double t129 = 2.0/9.0*vertices[3](1);
+  const double t131 = 4.0/9.0*vertices[0](2);
+  const double t132 = 2.0/9.0*vertices[1](2);
+  const double t133 = vertices[2](2)/9.0;
+  const double t134 = 2.0/9.0*vertices[3](2);
+  const double t136 = 2.0/9.0*vertices[0](0);
+  const double t137 = 4.0/9.0*vertices[1](0);
+  const double t138 = 2.0/9.0*vertices[2](0);
+  const double t139 = vertices[3](0)/9.0;
+  const double t141 = 2.0/9.0*vertices[0](1);
+  const double t142 = 4.0/9.0*vertices[1](1);
+  const double t143 = 2.0/9.0*vertices[2](1);
+  const double t144 = vertices[3](1)/9.0;
+  const double t146 = 2.0/9.0*vertices[0](2);
+  const double t147 = 4.0/9.0*vertices[1](2);
+  const double t148 = 2.0/9.0*vertices[2](2);
+  const double t149 = vertices[3](2)/9.0;
+  const double t151 = vertices[1](0)/9.0;
+  const double t152 = 4.0/9.0*vertices[3](0);
+  const double t154 = vertices[1](1)/9.0;
+  const double t155 = 4.0/9.0*vertices[3](1);
+  const double t157 = vertices[1](2)/9.0;
+  const double t158 = 4.0/9.0*vertices[3](2);
+  const double t160 = vertices[0](0)/9.0;
+  const double t161 = 4.0/9.0*vertices[2](0);
+  const double t163 = vertices[0](1)/9.0;
+  const double t164 = 4.0/9.0*vertices[2](1);
+  const double t166 = vertices[0](2)/9.0;
+  const double t167 = 4.0/9.0*vertices[2](2);
+  const double t169 = 4.0/9.0*vertices[4](0);
+  const double t170 = 2.0/9.0*vertices[5](0);
+  const double t171 = vertices[6](0)/9.0;
+  const double t172 = 2.0/9.0*vertices[7](0);
+  const double t174 = 4.0/9.0*vertices[4](1);
+  const double t175 = 2.0/9.0*vertices[5](1);
+  const double t176 = vertices[6](1)/9.0;
+  const double t177 = 2.0/9.0*vertices[7](1);
+  const double t179 = 4.0/9.0*vertices[4](2);
+  const double t180 = 2.0/9.0*vertices[5](2);
+  const double t181 = vertices[6](2)/9.0;
+  const double t182 = 2.0/9.0*vertices[7](2);
+  const double t184 = 2.0/9.0*vertices[4](0);
+  const double t185 = 4.0/9.0*vertices[5](0);
+  const double t186 = 2.0/9.0*vertices[6](0);
+  const double t187 = vertices[7](0)/9.0;
+  const double t189 = 2.0/9.0*vertices[4](1);
+  const double t190 = 4.0/9.0*vertices[5](1);
+  const double t191 = 2.0/9.0*vertices[6](1);
+  const double t192 = vertices[7](1)/9.0;
+  const double t194 = 2.0/9.0*vertices[4](2);
+  const double t195 = 4.0/9.0*vertices[5](2);
+  const double t196 = 2.0/9.0*vertices[6](2);
+  const double t197 = vertices[7](2)/9.0;
+  const double t199 = vertices[5](0)/9.0;
+  const double t200 = 4.0/9.0*vertices[7](0);
+  const double t202 = vertices[5](1)/9.0;
+  const double t203 = 4.0/9.0*vertices[7](1);
+  const double t205 = vertices[5](2)/9.0;
+  const double t206 = 4.0/9.0*vertices[7](2);
+  const double t208 = vertices[4](0)/9.0;
+  const double t209 = 4.0/9.0*vertices[6](0);
+  const double t211 = vertices[4](1)/9.0;
+  const double t212 = 4.0/9.0*vertices[6](1);
+  const double t214 = vertices[4](2)/9.0;
+  const double t215 = 4.0/9.0*vertices[6](2);
+  const double t266 = 4.0/27.0*vertices[1](0);
+  const double t267 = 2.0/27.0*vertices[2](0);
+  const double t268 = 4.0/27.0*vertices[3](0);
+  const double t269 = 4.0/27.0*vertices[4](0);
+  const double t270 = 2.0/27.0*vertices[5](0);
+  const double t272 = 2.0/27.0*vertices[7](0);
+  const double t275 = 4.0/27.0*vertices[1](1);
+  const double t276 = 2.0/27.0*vertices[2](1);
+  const double t277 = 4.0/27.0*vertices[3](1);
+  const double t278 = 4.0/27.0*vertices[4](1);
+  const double t279 = 2.0/27.0*vertices[5](1);
+  const double t281 = 2.0/27.0*vertices[7](1);
+  const double t284 = 4.0/27.0*vertices[1](2);
+  const double t285 = 2.0/27.0*vertices[2](2);
+  const double t286 = 4.0/27.0*vertices[3](2);
+  const double t287 = 4.0/27.0*vertices[4](2);
+  const double t288 = 2.0/27.0*vertices[5](2);
+  const double t290 = 2.0/27.0*vertices[7](2);
+  const double t292 = 4.0/27.0*vertices[0](0);
+  const double t294 = 4.0/27.0*vertices[2](0);
+  const double t295 = 2.0/27.0*vertices[3](0);
+  const double t296 = 2.0/27.0*vertices[4](0);
+  const double t297 = 4.0/27.0*vertices[5](0);
+  const double t298 = 2.0/27.0*vertices[6](0);
+  const double t301 = 4.0/27.0*vertices[0](1);
+  const double t303 = 4.0/27.0*vertices[2](1);
+  const double t304 = 2.0/27.0*vertices[3](1);
+  const double t305 = 2.0/27.0*vertices[4](1);
+  const double t306 = 4.0/27.0*vertices[5](1);
+  const double t307 = 2.0/27.0*vertices[6](1);
+  const double t310 = 4.0/27.0*vertices[0](2);
+  const double t312 = 4.0/27.0*vertices[2](2);
+  const double t313 = 2.0/27.0*vertices[3](2);
+  const double t314 = 2.0/27.0*vertices[4](2);
+  const double t315 = 4.0/27.0*vertices[5](2);
+  const double t316 = 2.0/27.0*vertices[6](2);
+  const double t319 = 2.0/27.0*vertices[1](0);
+  const double t322 = 4.0/27.0*vertices[7](0);
+  const double t324 = 2.0/27.0*vertices[1](1);
+  const double t327 = 4.0/27.0*vertices[7](1);
+  const double t329 = 2.0/27.0*vertices[1](2);
+  const double t332 = 4.0/27.0*vertices[7](2);
+  const double t334 = 2.0/27.0*vertices[0](0);
+  const double t337 = 4.0/27.0*vertices[6](0);
+  const double t339 = 2.0/27.0*vertices[0](1);
+  const double t342 = 4.0/27.0*vertices[6](1);
+  const double t344 = 2.0/27.0*vertices[0](2);
+  const double t347 = 4.0/27.0*vertices[6](2);
+      support_points[0](0) = vertices[0](0);
+      support_points[0](1) = vertices[0](1);
+      support_points[0](2) = vertices[0](2);
+      support_points[1](0) = vertices[1](0);
+      support_points[1](1) = vertices[1](1);
+      support_points[1](2) = vertices[1](2);
+      support_points[2](0) = vertices[2](0);
+      support_points[2](1) = vertices[2](1);
+      support_points[2](2) = vertices[2](2);
+      support_points[3](0) = vertices[3](0);
+      support_points[3](1) = vertices[3](1);
+      support_points[3](2) = vertices[3](2);
+      support_points[4](0) = vertices[4](0);
+      support_points[4](1) = vertices[4](1);
+      support_points[4](2) = vertices[4](2);
+      support_points[5](0) = vertices[5](0);
+      support_points[5](1) = vertices[5](1);
+      support_points[5](2) = vertices[5](2);
+      support_points[6](0) = vertices[6](0);
+      support_points[6](1) = vertices[6](1);
+      support_points[6](2) = vertices[6](2);
+      support_points[7](0) = vertices[7](0);
+      support_points[7](1) = vertices[7](1);
+      support_points[7](2) = vertices[7](2);
+      support_points[8](0) = t1+t2;
+      support_points[8](1) = t4+t5;
+      support_points[8](2) = t7+t8;
+      support_points[9](0) = t10+t11;
+      support_points[9](1) = t13+t14;
+      support_points[9](2) = t16+t17;
+      support_points[10](0) = t11+t19;
+      support_points[10](1) = t14+t21;
+      support_points[10](2) = t17+t23;
+      support_points[11](0) = t2+t25;
+      support_points[11](1) = t5+t27;
+      support_points[11](2) = t8+t29;
+      support_points[12](0) = t19+t31;
+      support_points[12](1) = t21+t33;
+      support_points[12](2) = t23+t35;
+      support_points[13](0) = t25+t37;
+      support_points[13](1) = t27+t39;
+      support_points[13](2) = t29+t41;
+      support_points[14](0) = t1+t37;
+      support_points[14](1) = t4+t39;
+      support_points[14](2) = t7+t41;
+      support_points[15](0) = t10+t31;
+      support_points[15](1) = t13+t33;
+      support_points[15](2) = t16+t35;
+      support_points[16](0) = t49+t50;
+      support_points[16](1) = t52+t53;
+      support_points[16](2) = t55+t56;
+      support_points[17](0) = t58+t59;
+      support_points[17](1) = t61+t62;
+      support_points[17](2) = t64+t65;
+      support_points[18](0) = t59+t67;
+      support_points[18](1) = t62+t69;
+      support_points[18](2) = t65+t71;
+      support_points[19](0) = t50+t73;
+      support_points[19](1) = t53+t75;
+      support_points[19](2) = t56+t77;
+      support_points[20](0) = t67+t79;
+      support_points[20](1) = t69+t81;
+      support_points[20](2) = t71+t83;
+      support_points[21](0) = t73+t85;
+      support_points[21](1) = t75+t87;
+      support_points[21](2) = t77+t89;
+      support_points[22](0) = t49+t85;
+      support_points[22](1) = t52+t87;
+      support_points[22](2) = t55+t89;
+      support_points[23](0) = t58+t79;
+      support_points[23](1) = t61+t81;
+      support_points[23](2) = t64+t83;
+      support_points[24](0) = t1+t58;
+      support_points[24](1) = t4+t61;
+      support_points[24](2) = t7+t64;
+      support_points[25](0) = t10+t49;
+      support_points[25](1) = t13+t52;
+      support_points[25](2) = t16+t55;
+      support_points[26](0) = t11+t50;
+      support_points[26](1) = t14+t53;
+      support_points[26](2) = t17+t56;
+      support_points[27](0) = t2+t59;
+      support_points[27](1) = t5+t62;
+      support_points[27](2) = t8+t65;
+      support_points[28](0) = t25+t67;
+      support_points[28](1) = t27+t69;
+      support_points[28](2) = t29+t71;
+      support_points[29](0) = t19+t73;
+      support_points[29](1) = t21+t75;
+      support_points[29](2) = t23+t77;
+      support_points[30](0) = t31+t85;
+      support_points[30](1) = t33+t87;
+      support_points[30](2) = t35+t89;
+      support_points[31](0) = t37+t79;
+      support_points[31](1) = t39+t81;
+      support_points[31](2) = t41+t83;
+      support_points[32](0) = t121+t122+t123+t124;
+      support_points[32](1) = t126+t127+t128+t129;
+      support_points[32](2) = t131+t132+t133+t134;
+      support_points[33](0) = t136+t137+t138+t139;
+      support_points[33](1) = t141+t142+t143+t144;
+      support_points[33](2) = t146+t147+t148+t149;
+      support_points[34](0) = t136+t151+t138+t152;
+      support_points[34](1) = t141+t154+t143+t155;
+      support_points[34](2) = t146+t157+t148+t158;
+      support_points[35](0) = t160+t122+t161+t124;
+      support_points[35](1) = t163+t127+t164+t129;
+      support_points[35](2) = t166+t132+t167+t134;
+      support_points[36](0) = t169+t170+t171+t172;
+      support_points[36](1) = t174+t175+t176+t177;
+      support_points[36](2) = t179+t180+t181+t182;
+      support_points[37](0) = t184+t185+t186+t187;
+      support_points[37](1) = t189+t190+t191+t192;
+      support_points[37](2) = t194+t195+t196+t197;
+      support_points[38](0) = t184+t199+t186+t200;
+      support_points[38](1) = t189+t202+t191+t203;
+      support_points[38](2) = t194+t205+t196+t206;
+      support_points[39](0) = t208+t170+t209+t172;
+      support_points[39](1) = t211+t175+t212+t177;
+      support_points[39](2) = t214+t180+t215+t182;
+      support_points[40](0) = t121+t122+t184+t199;
+      support_points[40](1) = t126+t127+t189+t202;
+      support_points[40](2) = t131+t132+t194+t205;
+      support_points[41](0) = t136+t137+t208+t170;
+      support_points[41](1) = t141+t142+t211+t175;
+      support_points[41](2) = t146+t147+t214+t180;
+      support_points[42](0) = t136+t151+t169+t170;
+      support_points[42](1) = t141+t154+t174+t175;
+      support_points[42](2) = t146+t157+t179+t180;
+      support_points[43](0) = t160+t122+t184+t185;
+      support_points[43](1) = t163+t127+t189+t190;
+      support_points[43](2) = t166+t132+t194+t195;
+      support_points[44](0) = t137+t138+t170+t171;
+      support_points[44](1) = t142+t143+t175+t176;
+      support_points[44](2) = t147+t148+t180+t181;
+      support_points[45](0) = t122+t123+t185+t186;
+      support_points[45](1) = t127+t128+t190+t191;
+      support_points[45](2) = t132+t133+t195+t196;
+      support_points[46](0) = t122+t161+t199+t186;
+      support_points[46](1) = t127+t164+t202+t191;
+      support_points[46](2) = t132+t167+t205+t196;
+      support_points[47](0) = t151+t138+t170+t209;
+      support_points[47](1) = t154+t143+t175+t212;
+      support_points[47](2) = t157+t148+t180+t215;
+      support_points[48](0) = t138+t152+t171+t172;
+      support_points[48](1) = t143+t155+t176+t177;
+      support_points[48](2) = t148+t158+t181+t182;
+      support_points[49](0) = t161+t124+t186+t187;
+      support_points[49](1) = t164+t129+t191+t192;
+      support_points[49](2) = t167+t134+t196+t197;
+      support_points[50](0) = t123+t124+t186+t200;
+      support_points[50](1) = t128+t129+t191+t203;
+      support_points[50](2) = t133+t134+t196+t206;
+      support_points[51](0) = t138+t139+t209+t172;
+      support_points[51](1) = t143+t144+t212+t177;
+      support_points[51](2) = t148+t149+t215+t182;
+      support_points[52](0) = t121+t124+t184+t187;
+      support_points[52](1) = t126+t129+t189+t192;
+      support_points[52](2) = t131+t134+t194+t197;
+      support_points[53](0) = t136+t139+t169+t172;
+      support_points[53](1) = t141+t144+t174+t177;
+      support_points[53](2) = t146+t149+t179+t182;
+      support_points[54](0) = t136+t152+t208+t172;
+      support_points[54](1) = t141+t155+t211+t177;
+      support_points[54](2) = t146+t158+t214+t182;
+      support_points[55](0) = t160+t124+t184+t200;
+      support_points[55](1) = t163+t129+t189+t203;
+      support_points[55](2) = t166+t134+t194+t206;
+      support_points[56](0) = 8.0/27.0*vertices[0](0)+t266+t267+t268+t269+t270+vertices[6](0)/27.0+t272;
+      support_points[56](1) = 8.0/27.0*vertices[0](1)+t275+t276+t277+t278+t279+vertices[6](1)/27.0+t281;
+      support_points[56](2) = 8.0/27.0*vertices[0](2)+t284+t285+t286+t287+t288+vertices[6](2)/27.0+t290;
+      support_points[57](0) = t292+8.0/27.0*vertices[1](0)+t294+t295+t296+t297+t298+vertices[7](0)/27.0;
+      support_points[57](1) = t301+8.0/27.0*vertices[1](1)+t303+t304+t305+t306+t307+vertices[7](1)/27.0;
+      support_points[57](2) = t310+8.0/27.0*vertices[1](2)+t312+t313+t314+t315+t316+vertices[7](2)/27.0;
+      support_points[58](0) = t292+t319+vertices[2](0)/27.0+t295+8.0/27.0*vertices[4](0)+t297+t298+t322;
+      support_points[58](1) = t301+t324+vertices[2](1)/27.0+t304+8.0/27.0*vertices[4](1)+t306+t307+t327;
+      support_points[58](2) = t310+t329+vertices[2](2)/27.0+t313+8.0/27.0*vertices[4](2)+t315+t316+t332;
+      support_points[59](0) = t334+t266+t267+vertices[3](0)/27.0+t269+8.0/27.0*vertices[5](0)+t337+t272;
+      support_points[59](1) = t339+t275+t276+vertices[3](1)/27.0+t278+8.0/27.0*vertices[5](1)+t342+t281;
+      support_points[59](2) = t344+t284+t285+vertices[3](2)/27.0+t287+8.0/27.0*vertices[5](2)+t347+t290;
+      support_points[60](0) = t292+t319+t294+8.0/27.0*vertices[3](0)+t296+vertices[5](0)/27.0+t298+t322;
+      support_points[60](1) = t301+t324+t303+8.0/27.0*vertices[3](1)+t305+vertices[5](1)/27.0+t307+t327;
+      support_points[60](2) = t310+t329+t312+8.0/27.0*vertices[3](2)+t314+vertices[5](2)/27.0+t316+t332;
+      support_points[61](0) = t334+t266+8.0/27.0*vertices[2](0)+t268+vertices[4](0)/27.0+t270+t337+t272;
+      support_points[61](1) = t339+t275+8.0/27.0*vertices[2](1)+t277+vertices[4](1)/27.0+t279+t342+t281;
+      support_points[61](2) = t344+t284+8.0/27.0*vertices[2](2)+t286+vertices[4](2)/27.0+t288+t347+t290;
+      support_points[62](0) = t334+vertices[1](0)/27.0+t267+t268+t269+t270+t337+8.0/27.0*vertices[7](0);
+      support_points[62](1) = t339+vertices[1](1)/27.0+t276+t277+t278+t279+t342+8.0/27.0*vertices[7](1);
+      support_points[62](2) = t344+vertices[1](2)/27.0+t285+t286+t287+t288+t347+8.0/27.0*vertices[7](2);
+      support_points[63](0) = vertices[0](0)/27.0+t319+t294+t295+t296+t297+8.0/27.0*vertices[6](0)+t322;
+      support_points[63](1) = vertices[0](1)/27.0+t324+t303+t304+t305+t306+8.0/27.0*vertices[6](1)+t327;
+      support_points[63](2) = vertices[0](2)/27.0+t329+t312+t313+t314+t315+8.0/27.0*vertices[6](2)+t332;
+};
+
+
+
+template <>
+void FECubicSub<3>::get_face_support_points (const typename DoFHandler<3>::face_iterator &face,
+                                            const Boundary<3>  &,
+                                            vector<Point<3> >  &support_points) const {
+  Assert (support_points.size() == dofs_per_face,
+         ExcWrongFieldDimension (support_points.size(), dofs_per_face));
+
+  for (unsigned int vertex=0; vertex<2; ++vertex)
+    support_points[vertex] = face->vertex(vertex);
+
+  support_points[4]  = (2*support_points[0] + support_points[1]) / 3;
+  support_points[5]  = (support_points[0] + 2*support_points[1]) / 3;
+  support_points[6]  = (2*support_points[1] + support_points[2]) / 3;
+  support_points[7]  = (support_points[1] + 2*support_points[2]) / 3;
+  support_points[8]  = (2*support_points[3] + support_points[2]) / 3;
+  support_points[9]  = (support_points[3] + 2*support_points[2]) / 3;
+  support_points[10] = (2*support_points[0] + support_points[3]) / 3;
+  support_points[11] = (support_points[0] + 2*support_points[3]) / 3;
+
+  support_points[12] = (4*support_points[0] +
+                       2*support_points[1] +
+                       1*support_points[2] +
+                       2*support_points[3]  ) /9;
+  support_points[13] = (2*support_points[0] +
+                       4*support_points[1] +
+                       2*support_points[2] +
+                       1*support_points[3]  ) /9;
+  support_points[12] = (2*support_points[0] +
+                       1*support_points[1] +
+                       2*support_points[2] +
+                       4*support_points[3]  ) /9;
+  support_points[13] = (1*support_points[0] +
+                       2*support_points[1] +
+                       4*support_points[2] +
+                       2*support_points[3]  ) /9;
+};
+
+
+
+#endif // deal_II_dimension == 3
+#endif // 0
 
 
 // explicit instantiations
index 8382901fd20980f8aa510bcaf14a646720a0b984..5334f6f5c49af11aeacff2361ea3a98b74c8a830 100644 (file)
@@ -433,6 +433,453 @@ void FELinear<2>::get_unit_support_points (vector<Point<2> > &unit_points) const
 #endif
 
 
+#if deal_II_dimension == 3
+
+template <>
+FELinear<3>::FELinear () :
+               FELinearMapping<3> (1, 0, 0, 0)
+{
+  interface_constraints(0,0) = 1.0/4.0;
+  interface_constraints(0,1) = 1.0/4.0;
+  interface_constraints(0,2) = 1.0/4.0;
+  interface_constraints(0,3) = 1.0/4.0;
+  interface_constraints(1,0) = 1.0/2.0;
+  interface_constraints(1,1) = 1.0/2.0;
+  interface_constraints(2,1) = 1.0/2.0;
+  interface_constraints(2,2) = 1.0/2.0;
+  interface_constraints(3,2) = 1.0/2.0;
+  interface_constraints(3,3) = 1.0/2.0;
+  interface_constraints(4,0) = 1.0/2.0;
+  interface_constraints(4,3) = 1.0/2.0;
+
+  initialize_matrices ();
+};
+
+
+
+template <>
+FELinear<3>::FELinear (const int) :
+               FELinearMapping<3> (0, 0, 0, 8)
+{
+  initialize_matrices ();
+};
+
+
+
+template <>
+void FELinear<3>::initialize_matrices () {
+  restriction[0](0,0) = 1.0;
+  restriction[1](1,1) = 1.0;
+  restriction[2](2,2) = 1.0;
+  restriction[3](3,3) = 1.0;
+  restriction[4](4,4) = 1.0;
+  restriction[5](5,5) = 1.0;
+  restriction[6](6,6) = 1.0;
+  restriction[7](7,7) = 1.0;
+
+  prolongation[0](0,0) = 1.0;
+  prolongation[0](1,0) = 1.0/2.0;
+  prolongation[0](1,1) = 1.0/2.0;
+  prolongation[0](2,0) = 1.0/4.0;
+  prolongation[0](2,1) = 1.0/4.0;
+  prolongation[0](2,2) = 1.0/4.0;
+  prolongation[0](2,3) = 1.0/4.0;
+  prolongation[0](3,0) = 1.0/2.0;
+  prolongation[0](3,3) = 1.0/2.0;
+  prolongation[0](4,0) = 1.0/2.0;
+  prolongation[0](4,4) = 1.0/2.0;
+  prolongation[0](5,0) = 1.0/4.0;
+  prolongation[0](5,1) = 1.0/4.0;
+  prolongation[0](5,4) = 1.0/4.0;
+  prolongation[0](5,5) = 1.0/4.0;
+  prolongation[0](6,0) = 1.0/8.0;
+  prolongation[0](6,1) = 1.0/8.0;
+  prolongation[0](6,2) = 1.0/8.0;
+  prolongation[0](6,3) = 1.0/8.0;
+  prolongation[0](6,4) = 1.0/8.0;
+  prolongation[0](6,5) = 1.0/8.0;
+  prolongation[0](6,6) = 1.0/8.0;
+  prolongation[0](6,7) = 1.0/8.0;
+  prolongation[0](7,0) = 1.0/4.0;
+  prolongation[0](7,3) = 1.0/4.0;
+  prolongation[0](7,4) = 1.0/4.0;
+  prolongation[0](7,7) = 1.0/4.0;
+  prolongation[1](0,0) = 1.0/2.0;
+  prolongation[1](0,1) = 1.0/2.0;
+  prolongation[1](1,1) = 1.0;
+  prolongation[1](2,1) = 1.0/2.0;
+  prolongation[1](2,2) = 1.0/2.0;
+  prolongation[1](3,0) = 1.0/4.0;
+  prolongation[1](3,1) = 1.0/4.0;
+  prolongation[1](3,2) = 1.0/4.0;
+  prolongation[1](3,3) = 1.0/4.0;
+  prolongation[1](4,0) = 1.0/4.0;
+  prolongation[1](4,1) = 1.0/4.0;
+  prolongation[1](4,4) = 1.0/4.0;
+  prolongation[1](4,5) = 1.0/4.0;
+  prolongation[1](5,1) = 1.0/2.0;
+  prolongation[1](5,5) = 1.0/2.0;
+  prolongation[1](6,1) = 1.0/4.0;
+  prolongation[1](6,2) = 1.0/4.0;
+  prolongation[1](6,5) = 1.0/4.0;
+  prolongation[1](6,6) = 1.0/4.0;
+  prolongation[1](7,0) = 1.0/8.0;
+  prolongation[1](7,1) = 1.0/8.0;
+  prolongation[1](7,2) = 1.0/8.0;
+  prolongation[1](7,3) = 1.0/8.0;
+  prolongation[1](7,4) = 1.0/8.0;
+  prolongation[1](7,5) = 1.0/8.0;
+  prolongation[1](7,6) = 1.0/8.0;
+  prolongation[1](7,7) = 1.0/8.0;
+  prolongation[2](0,0) = 1.0/4.0;
+  prolongation[2](0,1) = 1.0/4.0;
+  prolongation[2](0,2) = 1.0/4.0;
+  prolongation[2](0,3) = 1.0/4.0;
+  prolongation[2](1,1) = 1.0/2.0;
+  prolongation[2](1,2) = 1.0/2.0;
+  prolongation[2](2,2) = 1.0;
+  prolongation[2](3,2) = 1.0/2.0;
+  prolongation[2](3,3) = 1.0/2.0;
+  prolongation[2](4,0) = 1.0/8.0;
+  prolongation[2](4,1) = 1.0/8.0;
+  prolongation[2](4,2) = 1.0/8.0;
+  prolongation[2](4,3) = 1.0/8.0;
+  prolongation[2](4,4) = 1.0/8.0;
+  prolongation[2](4,5) = 1.0/8.0;
+  prolongation[2](4,6) = 1.0/8.0;
+  prolongation[2](4,7) = 1.0/8.0;
+  prolongation[2](5,1) = 1.0/4.0;
+  prolongation[2](5,2) = 1.0/4.0;
+  prolongation[2](5,5) = 1.0/4.0;
+  prolongation[2](5,6) = 1.0/4.0;
+  prolongation[2](6,2) = 1.0/2.0;
+  prolongation[2](6,6) = 1.0/2.0;
+  prolongation[2](7,2) = 1.0/4.0;
+  prolongation[2](7,3) = 1.0/4.0;
+  prolongation[2](7,6) = 1.0/4.0;
+  prolongation[2](7,7) = 1.0/4.0;
+  prolongation[3](0,0) = 1.0/2.0;
+  prolongation[3](0,3) = 1.0/2.0;
+  prolongation[3](1,0) = 1.0/4.0;
+  prolongation[3](1,1) = 1.0/4.0;
+  prolongation[3](1,2) = 1.0/4.0;
+  prolongation[3](1,3) = 1.0/4.0;
+  prolongation[3](2,2) = 1.0/2.0;
+  prolongation[3](2,3) = 1.0/2.0;
+  prolongation[3](3,3) = 1.0;
+  prolongation[3](4,0) = 1.0/4.0;
+  prolongation[3](4,3) = 1.0/4.0;
+  prolongation[3](4,4) = 1.0/4.0;
+  prolongation[3](4,7) = 1.0/4.0;
+  prolongation[3](5,0) = 1.0/8.0;
+  prolongation[3](5,1) = 1.0/8.0;
+  prolongation[3](5,2) = 1.0/8.0;
+  prolongation[3](5,3) = 1.0/8.0;
+  prolongation[3](5,4) = 1.0/8.0;
+  prolongation[3](5,5) = 1.0/8.0;
+  prolongation[3](5,6) = 1.0/8.0;
+  prolongation[3](5,7) = 1.0/8.0;
+  prolongation[3](6,2) = 1.0/4.0;
+  prolongation[3](6,3) = 1.0/4.0;
+  prolongation[3](6,6) = 1.0/4.0;
+  prolongation[3](6,7) = 1.0/4.0;
+  prolongation[3](7,3) = 1.0/2.0;
+  prolongation[3](7,7) = 1.0/2.0;
+  prolongation[4](0,0) = 1.0/2.0;
+  prolongation[4](0,4) = 1.0/2.0;
+  prolongation[4](1,0) = 1.0/4.0;
+  prolongation[4](1,1) = 1.0/4.0;
+  prolongation[4](1,4) = 1.0/4.0;
+  prolongation[4](1,5) = 1.0/4.0;
+  prolongation[4](2,0) = 1.0/8.0;
+  prolongation[4](2,1) = 1.0/8.0;
+  prolongation[4](2,2) = 1.0/8.0;
+  prolongation[4](2,3) = 1.0/8.0;
+  prolongation[4](2,4) = 1.0/8.0;
+  prolongation[4](2,5) = 1.0/8.0;
+  prolongation[4](2,6) = 1.0/8.0;
+  prolongation[4](2,7) = 1.0/8.0;
+  prolongation[4](3,0) = 1.0/4.0;
+  prolongation[4](3,3) = 1.0/4.0;
+  prolongation[4](3,4) = 1.0/4.0;
+  prolongation[4](3,7) = 1.0/4.0;
+  prolongation[4](4,4) = 1.0;
+  prolongation[4](5,4) = 1.0/2.0;
+  prolongation[4](5,5) = 1.0/2.0;
+  prolongation[4](6,4) = 1.0/4.0;
+  prolongation[4](6,5) = 1.0/4.0;
+  prolongation[4](6,6) = 1.0/4.0;
+  prolongation[4](6,7) = 1.0/4.0;
+  prolongation[4](7,4) = 1.0/2.0;
+  prolongation[4](7,7) = 1.0/2.0;
+  prolongation[5](0,0) = 1.0/4.0;
+  prolongation[5](0,1) = 1.0/4.0;
+  prolongation[5](0,4) = 1.0/4.0;
+  prolongation[5](0,5) = 1.0/4.0;
+  prolongation[5](1,1) = 1.0/2.0;
+  prolongation[5](1,5) = 1.0/2.0;
+  prolongation[5](2,1) = 1.0/4.0;
+  prolongation[5](2,2) = 1.0/4.0;
+  prolongation[5](2,5) = 1.0/4.0;
+  prolongation[5](2,6) = 1.0/4.0;
+  prolongation[5](3,0) = 1.0/8.0;
+  prolongation[5](3,1) = 1.0/8.0;
+  prolongation[5](3,2) = 1.0/8.0;
+  prolongation[5](3,3) = 1.0/8.0;
+  prolongation[5](3,4) = 1.0/8.0;
+  prolongation[5](3,5) = 1.0/8.0;
+  prolongation[5](3,6) = 1.0/8.0;
+  prolongation[5](3,7) = 1.0/8.0;
+  prolongation[5](4,4) = 1.0/2.0;
+  prolongation[5](4,5) = 1.0/2.0;
+  prolongation[5](5,5) = 1.0;
+  prolongation[5](6,5) = 1.0/2.0;
+  prolongation[5](6,6) = 1.0/2.0;
+  prolongation[5](7,4) = 1.0/4.0;
+  prolongation[5](7,5) = 1.0/4.0;
+  prolongation[5](7,6) = 1.0/4.0;
+  prolongation[5](7,7) = 1.0/4.0;
+  prolongation[6](0,0) = 1.0/8.0;
+  prolongation[6](0,1) = 1.0/8.0;
+  prolongation[6](0,2) = 1.0/8.0;
+  prolongation[6](0,3) = 1.0/8.0;
+  prolongation[6](0,4) = 1.0/8.0;
+  prolongation[6](0,5) = 1.0/8.0;
+  prolongation[6](0,6) = 1.0/8.0;
+  prolongation[6](0,7) = 1.0/8.0;
+  prolongation[6](1,1) = 1.0/4.0;
+  prolongation[6](1,2) = 1.0/4.0;
+  prolongation[6](1,5) = 1.0/4.0;
+  prolongation[6](1,6) = 1.0/4.0;
+  prolongation[6](2,2) = 1.0/2.0;
+  prolongation[6](2,6) = 1.0/2.0;
+  prolongation[6](3,2) = 1.0/4.0;
+  prolongation[6](3,3) = 1.0/4.0;
+  prolongation[6](3,6) = 1.0/4.0;
+  prolongation[6](3,7) = 1.0/4.0;
+  prolongation[6](4,4) = 1.0/4.0;
+  prolongation[6](4,5) = 1.0/4.0;
+  prolongation[6](4,6) = 1.0/4.0;
+  prolongation[6](4,7) = 1.0/4.0;
+  prolongation[6](5,5) = 1.0/2.0;
+  prolongation[6](5,6) = 1.0/2.0;
+  prolongation[6](6,6) = 1.0;
+  prolongation[6](7,6) = 1.0/2.0;
+  prolongation[6](7,7) = 1.0/2.0;
+  prolongation[7](0,0) = 1.0/4.0;
+  prolongation[7](0,3) = 1.0/4.0;
+  prolongation[7](0,4) = 1.0/4.0;
+  prolongation[7](0,7) = 1.0/4.0;
+  prolongation[7](1,0) = 1.0/8.0;
+  prolongation[7](1,1) = 1.0/8.0;
+  prolongation[7](1,2) = 1.0/8.0;
+  prolongation[7](1,3) = 1.0/8.0;
+  prolongation[7](1,4) = 1.0/8.0;
+  prolongation[7](1,5) = 1.0/8.0;
+  prolongation[7](1,6) = 1.0/8.0;
+  prolongation[7](1,7) = 1.0/8.0;
+  prolongation[7](2,2) = 1.0/4.0;
+  prolongation[7](2,3) = 1.0/4.0;
+  prolongation[7](2,6) = 1.0/4.0;
+  prolongation[7](2,7) = 1.0/4.0;
+  prolongation[7](3,3) = 1.0/2.0;
+  prolongation[7](3,7) = 1.0/2.0;
+  prolongation[7](4,4) = 1.0/2.0;
+  prolongation[7](4,7) = 1.0/2.0;
+  prolongation[7](5,4) = 1.0/4.0;
+  prolongation[7](5,5) = 1.0/4.0;
+  prolongation[7](5,6) = 1.0/4.0;
+  prolongation[7](5,7) = 1.0/4.0;
+  prolongation[7](6,6) = 1.0/2.0;
+  prolongation[7](6,7) = 1.0/2.0;
+  prolongation[7](7,7) = 1.0;
+};
+
+
+
+
+template <>
+inline
+double
+FELinear<3>::shape_value (const unsigned int i,
+                         const Point<3>& p) const
+{
+  Assert((i<total_dofs), ExcInvalidIndex(i));
+  switch (i)
+    {
+      case 0: return 1.0-p(0)+(-1.0+p(0))*p(1)+(-1.0+p(0)+(1.0-p(0))*p(1))*p(2);
+      case 1: return p(0)-p(0)*p(1)+(-p(0)+p(0)*p(1))*p(2);
+      case 2: return (p(0)-p(0)*p(1))*p(2);
+      case 3: return (1.0-p(0)+(-1.0+p(0))*p(1))*p(2);
+      case 4: return (1.0-p(0))*p(1)+(-1.0+p(0))*p(1)*p(2);
+      case 5: return p(0)*p(1)-p(0)*p(1)*p(2);
+      case 6: return p(0)*p(1)*p(2);
+      case 7: return (1.0-p(0))*p(1)*p(2);
+    }
+  return 0.;
+};
+
+
+
+template <>
+inline
+Tensor<1,3>
+FELinear<3>::shape_grad (const unsigned int i,
+                        const Point<3>& p) const
+{
+  Assert((i<total_dofs), ExcInvalidIndex(i));
+                                  // originally, the return type of the
+                                  // function was Point<dim>, so we
+                                  // still construct it as that. it should
+                                  // make no difference in practice,
+                                  // however
+  switch (i)
+    {
+      case 0: return Point<3>(-1.0+p(1)+(1.0-p(1))*p(2),
+                             -1.0+p(0)+(1.0-p(0))*p(2),
+                             -1.0+p(0)+(1.0-p(0))*p(1));
+      case 1: return Point<3>(1.0-p(1)+(-1.0+p(1))*p(2),
+                             -p(0)+p(0)*p(2),
+                             -p(0)+p(0)*p(1));
+      case 2: return Point<3>((1.0-p(1))*p(2),
+                             -p(0)*p(2),
+                             p(0)-p(0)*p(1));
+      case 3: return Point<3>((-1.0+p(1))*p(2),
+                             (-1.0+p(0))*p(2),
+                             1.0-p(0)+(-1.0+p(0))*p(1));
+      case 4: return Point<3>(-p(1)+p(1)*p(2),
+                             1.0-p(0)+(-1.0+p(0))*p(2),
+                             (-1.0+p(0))*p(1));
+      case 5: return Point<3>(p(1)-p(1)*p(2),
+                             p(0)-p(0)*p(2),
+                             -p(0)*p(1));
+      case 6: return Point<3>(p(1)*p(2),
+                             p(0)*p(2),
+                             p(0)*p(1));
+      case 7: return Point<3>(-p(1)*p(2),
+                             (1.0-p(0))*p(2),
+                             (1.0-p(0))*p(1));
+    }
+  return Point<3> ();
+};
+
+
+
+template <>
+inline
+Tensor<2,3>
+FELinear<3>::shape_grad_grad (const unsigned int i,
+                             const Point<3> &p) const
+{
+  Assert((i<total_dofs), ExcInvalidIndex(i));
+
+  Tensor<2,3> return_value;
+  
+  switch (i) 
+    {
+      case 0:
+           return_value[0][1] = 1.0-p(2);
+           return_value[0][2] = 1.0-p(1);
+           return_value[1][0] = 1.0-p(2);
+           return_value[1][2] = 1.0-p(0);
+           return_value[2][0] = 1.0-p(1);
+           return_value[2][1] = 1.0-p(0);
+           break;
+      case 1:
+           return_value[0][1] = -1.0+p(2);
+           return_value[0][2] = -1.0+p(1);
+           return_value[1][0] = -1.0+p(2);
+           return_value[1][2] = p(0);
+           return_value[2][0] = -1.0+p(1);
+           return_value[2][1] = p(0);
+           break;
+      case 2:
+           return_value[0][1] = -p(2);
+           return_value[0][2] = 1.0-p(1);
+           return_value[1][0] = -p(2);
+           return_value[1][2] = -p(0);
+           return_value[2][0] = 1.0-p(1);
+           return_value[2][1] = -p(0);
+           break;
+      case 3:
+           return_value[0][1] = p(2);
+           return_value[0][2] = -1.0+p(1);
+           return_value[1][0] = p(2);
+           return_value[1][2] = -1.0+p(0);
+           return_value[2][0] = -1.0+p(1);
+           return_value[2][1] = -1.0+p(0);
+           break;
+      case 4:
+           return_value[0][1] = -1.0+p(2);
+           return_value[0][2] = p(1);
+           return_value[1][0] = -1.0+p(2);
+           return_value[1][2] = -1.0+p(0);
+           return_value[2][0] = p(1);
+           return_value[2][1] = -1.0+p(0);
+           break;
+      case 5:
+           return_value[0][1] = 1.0-p(2);
+           return_value[0][2] = -p(1);
+           return_value[1][0] = 1.0-p(2);
+           return_value[1][2] = -p(0);
+           return_value[2][0] = -p(1);
+           return_value[2][1] = -p(0);
+           break;
+      case 6:
+           return_value[0][1] = p(2);
+           return_value[0][2] = p(1);
+           return_value[1][0] = p(2);
+           return_value[1][2] = p(0);
+           return_value[2][0] = p(1);
+           return_value[2][1] = p(0);
+           break;
+      case 7:
+           return_value[0][1] = -p(2);
+           return_value[0][2] = -p(1);
+           return_value[1][0] = -p(2);
+           return_value[1][2] = 1.0-p(0);
+           return_value[2][0] = -p(1);
+           return_value[2][1] = 1.0-p(0);
+    };
+  
+  return return_value;
+};
+
+
+
+template <>
+void FELinear<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
+                                        const Boundary<3> &,
+                                        dFMatrix &local_mass_matrix) const {
+  Assert (local_mass_matrix.n() == total_dofs,
+         ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
+  Assert (local_mass_matrix.m() == total_dofs,
+         ExcWrongFieldDimension(local_mass_matrix.m(),total_dofs));
+
+  AssertThrow (false, ExcComputationNotUseful(3));
+};
+
+
+
+template <>
+void FELinear<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
+  Assert (unit_points.size() == total_dofs,
+         ExcWrongFieldDimension (unit_points.size(), total_dofs));
+
+  unit_points[0] = Point<3> (0,0,0);
+  unit_points[1] = Point<3> (1,0,0);
+  unit_points[2] = Point<3> (1,0,1);
+  unit_points[3] = Point<3> (0,0,1);
+  unit_points[4] = Point<3> (0,1,0);
+  unit_points[5] = Point<3> (1,1,0);
+  unit_points[6] = Point<3> (1,1,1);
+  unit_points[7] = Point<3> (0,1,1);
+};
+  
+
+#endif
+
+
 
 template <int dim>
 void
index 89a40fc3435283c9aed8f5e7ea569295262a0677..7f60977ba7ce41c08aab68239677366b0fc8a24a 100644 (file)
@@ -1119,8 +1119,1829 @@ void FEQuadraticSub<2>::get_face_support_points (const typename DoFHandler<2>::f
   support_points[2] = (support_points[0] + support_points[1]) / 2;
 };
 
+#endif
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+FEQuadraticSub<3>::FEQuadraticSub () :
+               FELinearMapping<3> (1, 1, 1, 1)
+{
+  interface_constraints(0,8) = 1.0;
+  interface_constraints(1,4) = 1.0;
+  interface_constraints(2,5) = 1.0;
+  interface_constraints(3,6) = 1.0;
+  interface_constraints(4,7) = 1.0;
+  interface_constraints(5,4) = 3.0/8.0;
+  interface_constraints(5,6) = -1.0/8.0;
+  interface_constraints(5,8) = 3.0/4.0;
+  interface_constraints(6,5) = 3.0/8.0;
+  interface_constraints(6,7) = -1.0/8.0;
+  interface_constraints(6,8) = 3.0/4.0;
+  interface_constraints(7,4) = -1.0/8.0;
+  interface_constraints(7,6) = 3.0/8.0;
+  interface_constraints(7,8) = 3.0/4.0;
+  interface_constraints(8,5) = -1.0/8.0;
+  interface_constraints(8,7) = 3.0/8.0;
+  interface_constraints(8,8) = 3.0/4.0;
+  interface_constraints(9,0) = 3.0/8.0;
+  interface_constraints(9,1) = -1.0/8.0;
+  interface_constraints(9,4) = 3.0/4.0;
+  interface_constraints(10,0) = -1.0/8.0;
+  interface_constraints(10,1) = 3.0/8.0;
+  interface_constraints(10,4) = 3.0/4.0;
+  interface_constraints(11,1) = 3.0/8.0;
+  interface_constraints(11,2) = -1.0/8.0;
+  interface_constraints(11,5) = 3.0/4.0;
+  interface_constraints(12,1) = -1.0/8.0;
+  interface_constraints(12,2) = 3.0/8.0;
+  interface_constraints(12,5) = 3.0/4.0;
+  interface_constraints(13,2) = -1.0/8.0;
+  interface_constraints(13,3) = 3.0/8.0;
+  interface_constraints(13,6) = 3.0/4.0;
+  interface_constraints(14,2) = 3.0/8.0;
+  interface_constraints(14,3) = -1.0/8.0;
+  interface_constraints(14,6) = 3.0/4.0;
+  interface_constraints(15,0) = 3.0/8.0;
+  interface_constraints(15,3) = -1.0/8.0;
+  interface_constraints(15,7) = 3.0/4.0;
+  interface_constraints(16,0) = -1.0/8.0;
+  interface_constraints(16,3) = 3.0/8.0;
+  interface_constraints(16,7) = 3.0/4.0;
+  interface_constraints(17,0) = 9.0/64.0;
+  interface_constraints(17,1) = -3.0/64.0;
+  interface_constraints(17,2) = 1.0/64.0;
+  interface_constraints(17,3) = -3.0/64.0;
+  interface_constraints(17,4) = 9.0/32.0;
+  interface_constraints(17,5) = -3.0/32.0;
+  interface_constraints(17,6) = -3.0/32.0;
+  interface_constraints(17,7) = 9.0/32.0;
+  interface_constraints(17,8) = 9.0/16.0;
+  interface_constraints(18,0) = -3.0/64.0;
+  interface_constraints(18,1) = 9.0/64.0;
+  interface_constraints(18,2) = -3.0/64.0;
+  interface_constraints(18,3) = 1.0/64.0;
+  interface_constraints(18,4) = 9.0/32.0;
+  interface_constraints(18,5) = 9.0/32.0;
+  interface_constraints(18,6) = -3.0/32.0;
+  interface_constraints(18,7) = -3.0/32.0;
+  interface_constraints(18,8) = 9.0/16.0;
+  interface_constraints(19,0) = 1.0/64.0;
+  interface_constraints(19,1) = -3.0/64.0;
+  interface_constraints(19,2) = 9.0/64.0;
+  interface_constraints(19,3) = -3.0/64.0;
+  interface_constraints(19,4) = -3.0/32.0;
+  interface_constraints(19,5) = 9.0/32.0;
+  interface_constraints(19,6) = 9.0/32.0;
+  interface_constraints(19,7) = -3.0/32.0;
+  interface_constraints(19,8) = 9.0/16.0;
+  interface_constraints(20,0) = -3.0/64.0;
+  interface_constraints(20,1) = 1.0/64.0;
+  interface_constraints(20,2) = -3.0/64.0;
+  interface_constraints(20,3) = 9.0/64.0;
+  interface_constraints(20,4) = -3.0/32.0;
+  interface_constraints(20,5) = -3.0/32.0;
+  interface_constraints(20,6) = 9.0/32.0;
+  interface_constraints(20,7) = 9.0/32.0;
+  interface_constraints(20,8) = 9.0/16.0;
+
+  initialize_matrices ();
+};
+
+
+
+template <>
+FEQuadraticSub<3>::FEQuadraticSub (const int) :
+               FELinearMapping<3> (0, 0, 0, 27)
+{
+  initialize_matrices ();
+};
+
+
+
+template <>
+void FEQuadraticSub<3>::initialize_matrices () {
+  prolongation[0](0,0) = 1.0;
+  prolongation[0](1,8) = 1.0;
+  prolongation[0](2,20) = 1.0;
+  prolongation[0](3,11) = 1.0;
+  prolongation[0](4,16) = 1.0;
+  prolongation[0](5,22) = 1.0;
+  prolongation[0](6,26) = 1.0;
+  prolongation[0](7,25) = 1.0;
+  prolongation[0](8,0) = 3.0/8.0;
+  prolongation[0](8,1) = -1.0/8.0;
+  prolongation[0](8,8) = 3.0/4.0;
+  prolongation[0](9,8) = 3.0/8.0;
+  prolongation[0](9,10) = -1.0/8.0;
+  prolongation[0](9,20) = 3.0/4.0;
+  prolongation[0](10,9) = -1.0/8.0;
+  prolongation[0](10,11) = 3.0/8.0;
+  prolongation[0](10,20) = 3.0/4.0;
+  prolongation[0](11,0) = 3.0/8.0;
+  prolongation[0](11,3) = -1.0/8.0;
+  prolongation[0](11,11) = 3.0/4.0;
+  prolongation[0](12,16) = 3.0/8.0;
+  prolongation[0](12,17) = -1.0/8.0;
+  prolongation[0](12,22) = 3.0/4.0;
+  prolongation[0](13,22) = 3.0/8.0;
+  prolongation[0](13,24) = -1.0/8.0;
+  prolongation[0](13,26) = 3.0/4.0;
+  prolongation[0](14,23) = -1.0/8.0;
+  prolongation[0](14,25) = 3.0/8.0;
+  prolongation[0](14,26) = 3.0/4.0;
+  prolongation[0](15,16) = 3.0/8.0;
+  prolongation[0](15,19) = -1.0/8.0;
+  prolongation[0](15,25) = 3.0/4.0;
+  prolongation[0](16,0) = 3.0/8.0;
+  prolongation[0](16,4) = -1.0/8.0;
+  prolongation[0](16,16) = 3.0/4.0;
+  prolongation[0](17,8) = 3.0/8.0;
+  prolongation[0](17,12) = -1.0/8.0;
+  prolongation[0](17,22) = 3.0/4.0;
+  prolongation[0](18,20) = 3.0/8.0;
+  prolongation[0](18,21) = -1.0/8.0;
+  prolongation[0](18,26) = 3.0/4.0;
+  prolongation[0](19,11) = 3.0/8.0;
+  prolongation[0](19,15) = -1.0/8.0;
+  prolongation[0](19,25) = 3.0/4.0;
+  prolongation[0](20,0) = 9.0/64.0;
+  prolongation[0](20,1) = -3.0/64.0;
+  prolongation[0](20,2) = 1.0/64.0;
+  prolongation[0](20,3) = -3.0/64.0;
+  prolongation[0](20,8) = 9.0/32.0;
+  prolongation[0](20,9) = -3.0/32.0;
+  prolongation[0](20,10) = -3.0/32.0;
+  prolongation[0](20,11) = 9.0/32.0;
+  prolongation[0](20,20) = 9.0/16.0;
+  prolongation[0](21,16) = 9.0/64.0;
+  prolongation[0](21,17) = -3.0/64.0;
+  prolongation[0](21,18) = 1.0/64.0;
+  prolongation[0](21,19) = -3.0/64.0;
+  prolongation[0](21,22) = 9.0/32.0;
+  prolongation[0](21,23) = -3.0/32.0;
+  prolongation[0](21,24) = -3.0/32.0;
+  prolongation[0](21,25) = 9.0/32.0;
+  prolongation[0](21,26) = 9.0/16.0;
+  prolongation[0](22,0) = 9.0/64.0;
+  prolongation[0](22,1) = -3.0/64.0;
+  prolongation[0](22,4) = -3.0/64.0;
+  prolongation[0](22,5) = 1.0/64.0;
+  prolongation[0](22,8) = 9.0/32.0;
+  prolongation[0](22,12) = -3.0/32.0;
+  prolongation[0](22,16) = 9.0/32.0;
+  prolongation[0](22,17) = -3.0/32.0;
+  prolongation[0](22,22) = 9.0/16.0;
+  prolongation[0](23,8) = 9.0/64.0;
+  prolongation[0](23,10) = -3.0/64.0;
+  prolongation[0](23,12) = -3.0/64.0;
+  prolongation[0](23,14) = 1.0/64.0;
+  prolongation[0](23,20) = 9.0/32.0;
+  prolongation[0](23,21) = -3.0/32.0;
+  prolongation[0](23,22) = 9.0/32.0;
+  prolongation[0](23,24) = -3.0/32.0;
+  prolongation[0](23,26) = 9.0/16.0;
+  prolongation[0](24,9) = -3.0/64.0;
+  prolongation[0](24,11) = 9.0/64.0;
+  prolongation[0](24,13) = 1.0/64.0;
+  prolongation[0](24,15) = -3.0/64.0;
+  prolongation[0](24,20) = 9.0/32.0;
+  prolongation[0](24,21) = -3.0/32.0;
+  prolongation[0](24,23) = -3.0/32.0;
+  prolongation[0](24,25) = 9.0/32.0;
+  prolongation[0](24,26) = 9.0/16.0;
+  prolongation[0](25,0) = 9.0/64.0;
+  prolongation[0](25,3) = -3.0/64.0;
+  prolongation[0](25,4) = -3.0/64.0;
+  prolongation[0](25,7) = 1.0/64.0;
+  prolongation[0](25,11) = 9.0/32.0;
+  prolongation[0](25,15) = -3.0/32.0;
+  prolongation[0](25,16) = 9.0/32.0;
+  prolongation[0](25,19) = -3.0/32.0;
+  prolongation[0](25,25) = 9.0/16.0;
+  prolongation[0](26,0) = 27.0/512.0;
+  prolongation[0](26,1) = -9.0/512.0;
+  prolongation[0](26,2) = 3.0/512.0;
+  prolongation[0](26,3) = -9.0/512.0;
+  prolongation[0](26,4) = -9.0/512.0;
+  prolongation[0](26,5) = 3.0/512.0;
+  prolongation[0](26,6) = -1.0/512.0;
+  prolongation[0](26,7) = 3.0/512.0;
+  prolongation[0](26,8) = 27.0/256.0;
+  prolongation[0](26,9) = -9.0/256.0;
+  prolongation[0](26,10) = -9.0/256.0;
+  prolongation[0](26,11) = 27.0/256.0;
+  prolongation[0](26,12) = -9.0/256.0;
+  prolongation[0](26,13) = 3.0/256.0;
+  prolongation[0](26,14) = 3.0/256.0;
+  prolongation[0](26,15) = -9.0/256.0;
+  prolongation[0](26,16) = 27.0/256.0;
+  prolongation[0](26,17) = -9.0/256.0;
+  prolongation[0](26,18) = 3.0/256.0;
+  prolongation[0](26,19) = -9.0/256.0;
+  prolongation[0](26,20) = 27.0/128.0;
+  prolongation[0](26,21) = -9.0/128.0;
+  prolongation[0](26,22) = 27.0/128.0;
+  prolongation[0](26,23) = -9.0/128.0;
+  prolongation[0](26,24) = -9.0/128.0;
+  prolongation[0](26,25) = 27.0/128.0;
+  prolongation[0](26,26) = 27.0/64.0;
+  prolongation[1](0,8) = 1.0;
+  prolongation[1](1,1) = 1.0;
+  prolongation[1](2,9) = 1.0;
+  prolongation[1](3,20) = 1.0;
+  prolongation[1](4,22) = 1.0;
+  prolongation[1](5,17) = 1.0;
+  prolongation[1](6,23) = 1.0;
+  prolongation[1](7,26) = 1.0;
+  prolongation[1](8,0) = -1.0/8.0;
+  prolongation[1](8,1) = 3.0/8.0;
+  prolongation[1](8,8) = 3.0/4.0;
+  prolongation[1](9,1) = 3.0/8.0;
+  prolongation[1](9,2) = -1.0/8.0;
+  prolongation[1](9,9) = 3.0/4.0;
+  prolongation[1](10,9) = 3.0/8.0;
+  prolongation[1](10,11) = -1.0/8.0;
+  prolongation[1](10,20) = 3.0/4.0;
+  prolongation[1](11,8) = 3.0/8.0;
+  prolongation[1](11,10) = -1.0/8.0;
+  prolongation[1](11,20) = 3.0/4.0;
+  prolongation[1](12,16) = -1.0/8.0;
+  prolongation[1](12,17) = 3.0/8.0;
+  prolongation[1](12,22) = 3.0/4.0;
+  prolongation[1](13,17) = 3.0/8.0;
+  prolongation[1](13,18) = -1.0/8.0;
+  prolongation[1](13,23) = 3.0/4.0;
+  prolongation[1](14,23) = 3.0/8.0;
+  prolongation[1](14,25) = -1.0/8.0;
+  prolongation[1](14,26) = 3.0/4.0;
+  prolongation[1](15,22) = 3.0/8.0;
+  prolongation[1](15,24) = -1.0/8.0;
+  prolongation[1](15,26) = 3.0/4.0;
+  prolongation[1](16,8) = 3.0/8.0;
+  prolongation[1](16,12) = -1.0/8.0;
+  prolongation[1](16,22) = 3.0/4.0;
+  prolongation[1](17,1) = 3.0/8.0;
+  prolongation[1](17,5) = -1.0/8.0;
+  prolongation[1](17,17) = 3.0/4.0;
+  prolongation[1](18,9) = 3.0/8.0;
+  prolongation[1](18,13) = -1.0/8.0;
+  prolongation[1](18,23) = 3.0/4.0;
+  prolongation[1](19,20) = 3.0/8.0;
+  prolongation[1](19,21) = -1.0/8.0;
+  prolongation[1](19,26) = 3.0/4.0;
+  prolongation[1](20,0) = -3.0/64.0;
+  prolongation[1](20,1) = 9.0/64.0;
+  prolongation[1](20,2) = -3.0/64.0;
+  prolongation[1](20,3) = 1.0/64.0;
+  prolongation[1](20,8) = 9.0/32.0;
+  prolongation[1](20,9) = 9.0/32.0;
+  prolongation[1](20,10) = -3.0/32.0;
+  prolongation[1](20,11) = -3.0/32.0;
+  prolongation[1](20,20) = 9.0/16.0;
+  prolongation[1](21,16) = -3.0/64.0;
+  prolongation[1](21,17) = 9.0/64.0;
+  prolongation[1](21,18) = -3.0/64.0;
+  prolongation[1](21,19) = 1.0/64.0;
+  prolongation[1](21,22) = 9.0/32.0;
+  prolongation[1](21,23) = 9.0/32.0;
+  prolongation[1](21,24) = -3.0/32.0;
+  prolongation[1](21,25) = -3.0/32.0;
+  prolongation[1](21,26) = 9.0/16.0;
+  prolongation[1](22,0) = -3.0/64.0;
+  prolongation[1](22,1) = 9.0/64.0;
+  prolongation[1](22,4) = 1.0/64.0;
+  prolongation[1](22,5) = -3.0/64.0;
+  prolongation[1](22,8) = 9.0/32.0;
+  prolongation[1](22,12) = -3.0/32.0;
+  prolongation[1](22,16) = -3.0/32.0;
+  prolongation[1](22,17) = 9.0/32.0;
+  prolongation[1](22,22) = 9.0/16.0;
+  prolongation[1](23,1) = 9.0/64.0;
+  prolongation[1](23,2) = -3.0/64.0;
+  prolongation[1](23,5) = -3.0/64.0;
+  prolongation[1](23,6) = 1.0/64.0;
+  prolongation[1](23,9) = 9.0/32.0;
+  prolongation[1](23,13) = -3.0/32.0;
+  prolongation[1](23,17) = 9.0/32.0;
+  prolongation[1](23,18) = -3.0/32.0;
+  prolongation[1](23,23) = 9.0/16.0;
+  prolongation[1](24,9) = 9.0/64.0;
+  prolongation[1](24,11) = -3.0/64.0;
+  prolongation[1](24,13) = -3.0/64.0;
+  prolongation[1](24,15) = 1.0/64.0;
+  prolongation[1](24,20) = 9.0/32.0;
+  prolongation[1](24,21) = -3.0/32.0;
+  prolongation[1](24,23) = 9.0/32.0;
+  prolongation[1](24,25) = -3.0/32.0;
+  prolongation[1](24,26) = 9.0/16.0;
+  prolongation[1](25,8) = 9.0/64.0;
+  prolongation[1](25,10) = -3.0/64.0;
+  prolongation[1](25,12) = -3.0/64.0;
+  prolongation[1](25,14) = 1.0/64.0;
+  prolongation[1](25,20) = 9.0/32.0;
+  prolongation[1](25,21) = -3.0/32.0;
+  prolongation[1](25,22) = 9.0/32.0;
+  prolongation[1](25,24) = -3.0/32.0;
+  prolongation[1](25,26) = 9.0/16.0;
+  prolongation[1](26,0) = -9.0/512.0;
+  prolongation[1](26,1) = 27.0/512.0;
+  prolongation[1](26,2) = -9.0/512.0;
+  prolongation[1](26,3) = 3.0/512.0;
+  prolongation[1](26,4) = 3.0/512.0;
+  prolongation[1](26,5) = -9.0/512.0;
+  prolongation[1](26,6) = 3.0/512.0;
+  prolongation[1](26,7) = -1.0/512.0;
+  prolongation[1](26,8) = 27.0/256.0;
+  prolongation[1](26,9) = 27.0/256.0;
+  prolongation[1](26,10) = -9.0/256.0;
+  prolongation[1](26,11) = -9.0/256.0;
+  prolongation[1](26,12) = -9.0/256.0;
+  prolongation[1](26,13) = -9.0/256.0;
+  prolongation[1](26,14) = 3.0/256.0;
+  prolongation[1](26,15) = 3.0/256.0;
+  prolongation[1](26,16) = -9.0/256.0;
+  prolongation[1](26,17) = 27.0/256.0;
+  prolongation[1](26,18) = -9.0/256.0;
+  prolongation[1](26,19) = 3.0/256.0;
+  prolongation[1](26,20) = 27.0/128.0;
+  prolongation[1](26,21) = -9.0/128.0;
+  prolongation[1](26,22) = 27.0/128.0;
+  prolongation[1](26,23) = 27.0/128.0;
+  prolongation[1](26,24) = -9.0/128.0;
+  prolongation[1](26,25) = -9.0/128.0;
+  prolongation[1](26,26) = 27.0/64.0;
+  prolongation[2](0,20) = 1.0;
+  prolongation[2](1,9) = 1.0;
+  prolongation[2](2,2) = 1.0;
+  prolongation[2](3,10) = 1.0;
+  prolongation[2](4,26) = 1.0;
+  prolongation[2](5,23) = 1.0;
+  prolongation[2](6,18) = 1.0;
+  prolongation[2](7,24) = 1.0;
+  prolongation[2](8,9) = 3.0/8.0;
+  prolongation[2](8,11) = -1.0/8.0;
+  prolongation[2](8,20) = 3.0/4.0;
+  prolongation[2](9,1) = -1.0/8.0;
+  prolongation[2](9,2) = 3.0/8.0;
+  prolongation[2](9,9) = 3.0/4.0;
+  prolongation[2](10,2) = 3.0/8.0;
+  prolongation[2](10,3) = -1.0/8.0;
+  prolongation[2](10,10) = 3.0/4.0;
+  prolongation[2](11,8) = -1.0/8.0;
+  prolongation[2](11,10) = 3.0/8.0;
+  prolongation[2](11,20) = 3.0/4.0;
+  prolongation[2](12,23) = 3.0/8.0;
+  prolongation[2](12,25) = -1.0/8.0;
+  prolongation[2](12,26) = 3.0/4.0;
+  prolongation[2](13,17) = -1.0/8.0;
+  prolongation[2](13,18) = 3.0/8.0;
+  prolongation[2](13,23) = 3.0/4.0;
+  prolongation[2](14,18) = 3.0/8.0;
+  prolongation[2](14,19) = -1.0/8.0;
+  prolongation[2](14,24) = 3.0/4.0;
+  prolongation[2](15,22) = -1.0/8.0;
+  prolongation[2](15,24) = 3.0/8.0;
+  prolongation[2](15,26) = 3.0/4.0;
+  prolongation[2](16,20) = 3.0/8.0;
+  prolongation[2](16,21) = -1.0/8.0;
+  prolongation[2](16,26) = 3.0/4.0;
+  prolongation[2](17,9) = 3.0/8.0;
+  prolongation[2](17,13) = -1.0/8.0;
+  prolongation[2](17,23) = 3.0/4.0;
+  prolongation[2](18,2) = 3.0/8.0;
+  prolongation[2](18,6) = -1.0/8.0;
+  prolongation[2](18,18) = 3.0/4.0;
+  prolongation[2](19,10) = 3.0/8.0;
+  prolongation[2](19,14) = -1.0/8.0;
+  prolongation[2](19,24) = 3.0/4.0;
+  prolongation[2](20,0) = 1.0/64.0;
+  prolongation[2](20,1) = -3.0/64.0;
+  prolongation[2](20,2) = 9.0/64.0;
+  prolongation[2](20,3) = -3.0/64.0;
+  prolongation[2](20,8) = -3.0/32.0;
+  prolongation[2](20,9) = 9.0/32.0;
+  prolongation[2](20,10) = 9.0/32.0;
+  prolongation[2](20,11) = -3.0/32.0;
+  prolongation[2](20,20) = 9.0/16.0;
+  prolongation[2](21,16) = 1.0/64.0;
+  prolongation[2](21,17) = -3.0/64.0;
+  prolongation[2](21,18) = 9.0/64.0;
+  prolongation[2](21,19) = -3.0/64.0;
+  prolongation[2](21,22) = -3.0/32.0;
+  prolongation[2](21,23) = 9.0/32.0;
+  prolongation[2](21,24) = 9.0/32.0;
+  prolongation[2](21,25) = -3.0/32.0;
+  prolongation[2](21,26) = 9.0/16.0;
+  prolongation[2](22,9) = 9.0/64.0;
+  prolongation[2](22,11) = -3.0/64.0;
+  prolongation[2](22,13) = -3.0/64.0;
+  prolongation[2](22,15) = 1.0/64.0;
+  prolongation[2](22,20) = 9.0/32.0;
+  prolongation[2](22,21) = -3.0/32.0;
+  prolongation[2](22,23) = 9.0/32.0;
+  prolongation[2](22,25) = -3.0/32.0;
+  prolongation[2](22,26) = 9.0/16.0;
+  prolongation[2](23,1) = -3.0/64.0;
+  prolongation[2](23,2) = 9.0/64.0;
+  prolongation[2](23,5) = 1.0/64.0;
+  prolongation[2](23,6) = -3.0/64.0;
+  prolongation[2](23,9) = 9.0/32.0;
+  prolongation[2](23,13) = -3.0/32.0;
+  prolongation[2](23,17) = -3.0/32.0;
+  prolongation[2](23,18) = 9.0/32.0;
+  prolongation[2](23,23) = 9.0/16.0;
+  prolongation[2](24,2) = 9.0/64.0;
+  prolongation[2](24,3) = -3.0/64.0;
+  prolongation[2](24,6) = -3.0/64.0;
+  prolongation[2](24,7) = 1.0/64.0;
+  prolongation[2](24,10) = 9.0/32.0;
+  prolongation[2](24,14) = -3.0/32.0;
+  prolongation[2](24,18) = 9.0/32.0;
+  prolongation[2](24,19) = -3.0/32.0;
+  prolongation[2](24,24) = 9.0/16.0;
+  prolongation[2](25,8) = -3.0/64.0;
+  prolongation[2](25,10) = 9.0/64.0;
+  prolongation[2](25,12) = 1.0/64.0;
+  prolongation[2](25,14) = -3.0/64.0;
+  prolongation[2](25,20) = 9.0/32.0;
+  prolongation[2](25,21) = -3.0/32.0;
+  prolongation[2](25,22) = -3.0/32.0;
+  prolongation[2](25,24) = 9.0/32.0;
+  prolongation[2](25,26) = 9.0/16.0;
+  prolongation[2](26,0) = 3.0/512.0;
+  prolongation[2](26,1) = -9.0/512.0;
+  prolongation[2](26,2) = 27.0/512.0;
+  prolongation[2](26,3) = -9.0/512.0;
+  prolongation[2](26,4) = -1.0/512.0;
+  prolongation[2](26,5) = 3.0/512.0;
+  prolongation[2](26,6) = -9.0/512.0;
+  prolongation[2](26,7) = 3.0/512.0;
+  prolongation[2](26,8) = -9.0/256.0;
+  prolongation[2](26,9) = 27.0/256.0;
+  prolongation[2](26,10) = 27.0/256.0;
+  prolongation[2](26,11) = -9.0/256.0;
+  prolongation[2](26,12) = 3.0/256.0;
+  prolongation[2](26,13) = -9.0/256.0;
+  prolongation[2](26,14) = -9.0/256.0;
+  prolongation[2](26,15) = 3.0/256.0;
+  prolongation[2](26,16) = 3.0/256.0;
+  prolongation[2](26,17) = -9.0/256.0;
+  prolongation[2](26,18) = 27.0/256.0;
+  prolongation[2](26,19) = -9.0/256.0;
+  prolongation[2](26,20) = 27.0/128.0;
+  prolongation[2](26,21) = -9.0/128.0;
+  prolongation[2](26,22) = -9.0/128.0;
+  prolongation[2](26,23) = 27.0/128.0;
+  prolongation[2](26,24) = 27.0/128.0;
+  prolongation[2](26,25) = -9.0/128.0;
+  prolongation[2](26,26) = 27.0/64.0;
+  prolongation[3](0,11) = 1.0;
+  prolongation[3](1,20) = 1.0;
+  prolongation[3](2,10) = 1.0;
+  prolongation[3](3,3) = 1.0;
+  prolongation[3](4,25) = 1.0;
+  prolongation[3](5,26) = 1.0;
+  prolongation[3](6,24) = 1.0;
+  prolongation[3](7,19) = 1.0;
+  prolongation[3](8,9) = -1.0/8.0;
+  prolongation[3](8,11) = 3.0/8.0;
+  prolongation[3](8,20) = 3.0/4.0;
+  prolongation[3](9,8) = -1.0/8.0;
+  prolongation[3](9,10) = 3.0/8.0;
+  prolongation[3](9,20) = 3.0/4.0;
+  prolongation[3](10,2) = -1.0/8.0;
+  prolongation[3](10,3) = 3.0/8.0;
+  prolongation[3](10,10) = 3.0/4.0;
+  prolongation[3](11,0) = -1.0/8.0;
+  prolongation[3](11,3) = 3.0/8.0;
+  prolongation[3](11,11) = 3.0/4.0;
+  prolongation[3](12,23) = -1.0/8.0;
+  prolongation[3](12,25) = 3.0/8.0;
+  prolongation[3](12,26) = 3.0/4.0;
+  prolongation[3](13,22) = -1.0/8.0;
+  prolongation[3](13,24) = 3.0/8.0;
+  prolongation[3](13,26) = 3.0/4.0;
+  prolongation[3](14,18) = -1.0/8.0;
+  prolongation[3](14,19) = 3.0/8.0;
+  prolongation[3](14,24) = 3.0/4.0;
+  prolongation[3](15,16) = -1.0/8.0;
+  prolongation[3](15,19) = 3.0/8.0;
+  prolongation[3](15,25) = 3.0/4.0;
+  prolongation[3](16,11) = 3.0/8.0;
+  prolongation[3](16,15) = -1.0/8.0;
+  prolongation[3](16,25) = 3.0/4.0;
+  prolongation[3](17,20) = 3.0/8.0;
+  prolongation[3](17,21) = -1.0/8.0;
+  prolongation[3](17,26) = 3.0/4.0;
+  prolongation[3](18,10) = 3.0/8.0;
+  prolongation[3](18,14) = -1.0/8.0;
+  prolongation[3](18,24) = 3.0/4.0;
+  prolongation[3](19,3) = 3.0/8.0;
+  prolongation[3](19,7) = -1.0/8.0;
+  prolongation[3](19,19) = 3.0/4.0;
+  prolongation[3](20,0) = -3.0/64.0;
+  prolongation[3](20,1) = 1.0/64.0;
+  prolongation[3](20,2) = -3.0/64.0;
+  prolongation[3](20,3) = 9.0/64.0;
+  prolongation[3](20,8) = -3.0/32.0;
+  prolongation[3](20,9) = -3.0/32.0;
+  prolongation[3](20,10) = 9.0/32.0;
+  prolongation[3](20,11) = 9.0/32.0;
+  prolongation[3](20,20) = 9.0/16.0;
+  prolongation[3](21,16) = -3.0/64.0;
+  prolongation[3](21,17) = 1.0/64.0;
+  prolongation[3](21,18) = -3.0/64.0;
+  prolongation[3](21,19) = 9.0/64.0;
+  prolongation[3](21,22) = -3.0/32.0;
+  prolongation[3](21,23) = -3.0/32.0;
+  prolongation[3](21,24) = 9.0/32.0;
+  prolongation[3](21,25) = 9.0/32.0;
+  prolongation[3](21,26) = 9.0/16.0;
+  prolongation[3](22,9) = -3.0/64.0;
+  prolongation[3](22,11) = 9.0/64.0;
+  prolongation[3](22,13) = 1.0/64.0;
+  prolongation[3](22,15) = -3.0/64.0;
+  prolongation[3](22,20) = 9.0/32.0;
+  prolongation[3](22,21) = -3.0/32.0;
+  prolongation[3](22,23) = -3.0/32.0;
+  prolongation[3](22,25) = 9.0/32.0;
+  prolongation[3](22,26) = 9.0/16.0;
+  prolongation[3](23,8) = -3.0/64.0;
+  prolongation[3](23,10) = 9.0/64.0;
+  prolongation[3](23,12) = 1.0/64.0;
+  prolongation[3](23,14) = -3.0/64.0;
+  prolongation[3](23,20) = 9.0/32.0;
+  prolongation[3](23,21) = -3.0/32.0;
+  prolongation[3](23,22) = -3.0/32.0;
+  prolongation[3](23,24) = 9.0/32.0;
+  prolongation[3](23,26) = 9.0/16.0;
+  prolongation[3](24,2) = -3.0/64.0;
+  prolongation[3](24,3) = 9.0/64.0;
+  prolongation[3](24,6) = 1.0/64.0;
+  prolongation[3](24,7) = -3.0/64.0;
+  prolongation[3](24,10) = 9.0/32.0;
+  prolongation[3](24,14) = -3.0/32.0;
+  prolongation[3](24,18) = -3.0/32.0;
+  prolongation[3](24,19) = 9.0/32.0;
+  prolongation[3](24,24) = 9.0/16.0;
+  prolongation[3](25,0) = -3.0/64.0;
+  prolongation[3](25,3) = 9.0/64.0;
+  prolongation[3](25,4) = 1.0/64.0;
+  prolongation[3](25,7) = -3.0/64.0;
+  prolongation[3](25,11) = 9.0/32.0;
+  prolongation[3](25,15) = -3.0/32.0;
+  prolongation[3](25,16) = -3.0/32.0;
+  prolongation[3](25,19) = 9.0/32.0;
+  prolongation[3](25,25) = 9.0/16.0;
+  prolongation[3](26,0) = -9.0/512.0;
+  prolongation[3](26,1) = 3.0/512.0;
+  prolongation[3](26,2) = -9.0/512.0;
+  prolongation[3](26,3) = 27.0/512.0;
+  prolongation[3](26,4) = 3.0/512.0;
+  prolongation[3](26,5) = -1.0/512.0;
+  prolongation[3](26,6) = 3.0/512.0;
+  prolongation[3](26,7) = -9.0/512.0;
+  prolongation[3](26,8) = -9.0/256.0;
+  prolongation[3](26,9) = -9.0/256.0;
+  prolongation[3](26,10) = 27.0/256.0;
+  prolongation[3](26,11) = 27.0/256.0;
+  prolongation[3](26,12) = 3.0/256.0;
+  prolongation[3](26,13) = 3.0/256.0;
+  prolongation[3](26,14) = -9.0/256.0;
+  prolongation[3](26,15) = -9.0/256.0;
+  prolongation[3](26,16) = -9.0/256.0;
+  prolongation[3](26,17) = 3.0/256.0;
+  prolongation[3](26,18) = -9.0/256.0;
+  prolongation[3](26,19) = 27.0/256.0;
+  prolongation[3](26,20) = 27.0/128.0;
+  prolongation[3](26,21) = -9.0/128.0;
+  prolongation[3](26,22) = -9.0/128.0;
+  prolongation[3](26,23) = -9.0/128.0;
+  prolongation[3](26,24) = 27.0/128.0;
+  prolongation[3](26,25) = 27.0/128.0;
+  prolongation[3](26,26) = 27.0/64.0;
+  prolongation[4](0,16) = 1.0;
+  prolongation[4](1,22) = 1.0;
+  prolongation[4](2,26) = 1.0;
+  prolongation[4](3,25) = 1.0;
+  prolongation[4](4,4) = 1.0;
+  prolongation[4](5,12) = 1.0;
+  prolongation[4](6,21) = 1.0;
+  prolongation[4](7,15) = 1.0;
+  prolongation[4](8,16) = 3.0/8.0;
+  prolongation[4](8,17) = -1.0/8.0;
+  prolongation[4](8,22) = 3.0/4.0;
+  prolongation[4](9,22) = 3.0/8.0;
+  prolongation[4](9,24) = -1.0/8.0;
+  prolongation[4](9,26) = 3.0/4.0;
+  prolongation[4](10,23) = -1.0/8.0;
+  prolongation[4](10,25) = 3.0/8.0;
+  prolongation[4](10,26) = 3.0/4.0;
+  prolongation[4](11,16) = 3.0/8.0;
+  prolongation[4](11,19) = -1.0/8.0;
+  prolongation[4](11,25) = 3.0/4.0;
+  prolongation[4](12,4) = 3.0/8.0;
+  prolongation[4](12,5) = -1.0/8.0;
+  prolongation[4](12,12) = 3.0/4.0;
+  prolongation[4](13,12) = 3.0/8.0;
+  prolongation[4](13,14) = -1.0/8.0;
+  prolongation[4](13,21) = 3.0/4.0;
+  prolongation[4](14,13) = -1.0/8.0;
+  prolongation[4](14,15) = 3.0/8.0;
+  prolongation[4](14,21) = 3.0/4.0;
+  prolongation[4](15,4) = 3.0/8.0;
+  prolongation[4](15,7) = -1.0/8.0;
+  prolongation[4](15,15) = 3.0/4.0;
+  prolongation[4](16,0) = -1.0/8.0;
+  prolongation[4](16,4) = 3.0/8.0;
+  prolongation[4](16,16) = 3.0/4.0;
+  prolongation[4](17,8) = -1.0/8.0;
+  prolongation[4](17,12) = 3.0/8.0;
+  prolongation[4](17,22) = 3.0/4.0;
+  prolongation[4](18,20) = -1.0/8.0;
+  prolongation[4](18,21) = 3.0/8.0;
+  prolongation[4](18,26) = 3.0/4.0;
+  prolongation[4](19,11) = -1.0/8.0;
+  prolongation[4](19,15) = 3.0/8.0;
+  prolongation[4](19,25) = 3.0/4.0;
+  prolongation[4](20,16) = 9.0/64.0;
+  prolongation[4](20,17) = -3.0/64.0;
+  prolongation[4](20,18) = 1.0/64.0;
+  prolongation[4](20,19) = -3.0/64.0;
+  prolongation[4](20,22) = 9.0/32.0;
+  prolongation[4](20,23) = -3.0/32.0;
+  prolongation[4](20,24) = -3.0/32.0;
+  prolongation[4](20,25) = 9.0/32.0;
+  prolongation[4](20,26) = 9.0/16.0;
+  prolongation[4](21,4) = 9.0/64.0;
+  prolongation[4](21,5) = -3.0/64.0;
+  prolongation[4](21,6) = 1.0/64.0;
+  prolongation[4](21,7) = -3.0/64.0;
+  prolongation[4](21,12) = 9.0/32.0;
+  prolongation[4](21,13) = -3.0/32.0;
+  prolongation[4](21,14) = -3.0/32.0;
+  prolongation[4](21,15) = 9.0/32.0;
+  prolongation[4](21,21) = 9.0/16.0;
+  prolongation[4](22,0) = -3.0/64.0;
+  prolongation[4](22,1) = 1.0/64.0;
+  prolongation[4](22,4) = 9.0/64.0;
+  prolongation[4](22,5) = -3.0/64.0;
+  prolongation[4](22,8) = -3.0/32.0;
+  prolongation[4](22,12) = 9.0/32.0;
+  prolongation[4](22,16) = 9.0/32.0;
+  prolongation[4](22,17) = -3.0/32.0;
+  prolongation[4](22,22) = 9.0/16.0;
+  prolongation[4](23,8) = -3.0/64.0;
+  prolongation[4](23,10) = 1.0/64.0;
+  prolongation[4](23,12) = 9.0/64.0;
+  prolongation[4](23,14) = -3.0/64.0;
+  prolongation[4](23,20) = -3.0/32.0;
+  prolongation[4](23,21) = 9.0/32.0;
+  prolongation[4](23,22) = 9.0/32.0;
+  prolongation[4](23,24) = -3.0/32.0;
+  prolongation[4](23,26) = 9.0/16.0;
+  prolongation[4](24,9) = 1.0/64.0;
+  prolongation[4](24,11) = -3.0/64.0;
+  prolongation[4](24,13) = -3.0/64.0;
+  prolongation[4](24,15) = 9.0/64.0;
+  prolongation[4](24,20) = -3.0/32.0;
+  prolongation[4](24,21) = 9.0/32.0;
+  prolongation[4](24,23) = -3.0/32.0;
+  prolongation[4](24,25) = 9.0/32.0;
+  prolongation[4](24,26) = 9.0/16.0;
+  prolongation[4](25,0) = -3.0/64.0;
+  prolongation[4](25,3) = 1.0/64.0;
+  prolongation[4](25,4) = 9.0/64.0;
+  prolongation[4](25,7) = -3.0/64.0;
+  prolongation[4](25,11) = -3.0/32.0;
+  prolongation[4](25,15) = 9.0/32.0;
+  prolongation[4](25,16) = 9.0/32.0;
+  prolongation[4](25,19) = -3.0/32.0;
+  prolongation[4](25,25) = 9.0/16.0;
+  prolongation[4](26,0) = -9.0/512.0;
+  prolongation[4](26,1) = 3.0/512.0;
+  prolongation[4](26,2) = -1.0/512.0;
+  prolongation[4](26,3) = 3.0/512.0;
+  prolongation[4](26,4) = 27.0/512.0;
+  prolongation[4](26,5) = -9.0/512.0;
+  prolongation[4](26,6) = 3.0/512.0;
+  prolongation[4](26,7) = -9.0/512.0;
+  prolongation[4](26,8) = -9.0/256.0;
+  prolongation[4](26,9) = 3.0/256.0;
+  prolongation[4](26,10) = 3.0/256.0;
+  prolongation[4](26,11) = -9.0/256.0;
+  prolongation[4](26,12) = 27.0/256.0;
+  prolongation[4](26,13) = -9.0/256.0;
+  prolongation[4](26,14) = -9.0/256.0;
+  prolongation[4](26,15) = 27.0/256.0;
+  prolongation[4](26,16) = 27.0/256.0;
+  prolongation[4](26,17) = -9.0/256.0;
+  prolongation[4](26,18) = 3.0/256.0;
+  prolongation[4](26,19) = -9.0/256.0;
+  prolongation[4](26,20) = -9.0/128.0;
+  prolongation[4](26,21) = 27.0/128.0;
+  prolongation[4](26,22) = 27.0/128.0;
+  prolongation[4](26,23) = -9.0/128.0;
+  prolongation[4](26,24) = -9.0/128.0;
+  prolongation[4](26,25) = 27.0/128.0;
+  prolongation[4](26,26) = 27.0/64.0;
+  prolongation[5](0,22) = 1.0;
+  prolongation[5](1,17) = 1.0;
+  prolongation[5](2,23) = 1.0;
+  prolongation[5](3,26) = 1.0;
+  prolongation[5](4,12) = 1.0;
+  prolongation[5](5,5) = 1.0;
+  prolongation[5](6,13) = 1.0;
+  prolongation[5](7,21) = 1.0;
+  prolongation[5](8,16) = -1.0/8.0;
+  prolongation[5](8,17) = 3.0/8.0;
+  prolongation[5](8,22) = 3.0/4.0;
+  prolongation[5](9,17) = 3.0/8.0;
+  prolongation[5](9,18) = -1.0/8.0;
+  prolongation[5](9,23) = 3.0/4.0;
+  prolongation[5](10,23) = 3.0/8.0;
+  prolongation[5](10,25) = -1.0/8.0;
+  prolongation[5](10,26) = 3.0/4.0;
+  prolongation[5](11,22) = 3.0/8.0;
+  prolongation[5](11,24) = -1.0/8.0;
+  prolongation[5](11,26) = 3.0/4.0;
+  prolongation[5](12,4) = -1.0/8.0;
+  prolongation[5](12,5) = 3.0/8.0;
+  prolongation[5](12,12) = 3.0/4.0;
+  prolongation[5](13,5) = 3.0/8.0;
+  prolongation[5](13,6) = -1.0/8.0;
+  prolongation[5](13,13) = 3.0/4.0;
+  prolongation[5](14,13) = 3.0/8.0;
+  prolongation[5](14,15) = -1.0/8.0;
+  prolongation[5](14,21) = 3.0/4.0;
+  prolongation[5](15,12) = 3.0/8.0;
+  prolongation[5](15,14) = -1.0/8.0;
+  prolongation[5](15,21) = 3.0/4.0;
+  prolongation[5](16,8) = -1.0/8.0;
+  prolongation[5](16,12) = 3.0/8.0;
+  prolongation[5](16,22) = 3.0/4.0;
+  prolongation[5](17,1) = -1.0/8.0;
+  prolongation[5](17,5) = 3.0/8.0;
+  prolongation[5](17,17) = 3.0/4.0;
+  prolongation[5](18,9) = -1.0/8.0;
+  prolongation[5](18,13) = 3.0/8.0;
+  prolongation[5](18,23) = 3.0/4.0;
+  prolongation[5](19,20) = -1.0/8.0;
+  prolongation[5](19,21) = 3.0/8.0;
+  prolongation[5](19,26) = 3.0/4.0;
+  prolongation[5](20,16) = -3.0/64.0;
+  prolongation[5](20,17) = 9.0/64.0;
+  prolongation[5](20,18) = -3.0/64.0;
+  prolongation[5](20,19) = 1.0/64.0;
+  prolongation[5](20,22) = 9.0/32.0;
+  prolongation[5](20,23) = 9.0/32.0;
+  prolongation[5](20,24) = -3.0/32.0;
+  prolongation[5](20,25) = -3.0/32.0;
+  prolongation[5](20,26) = 9.0/16.0;
+  prolongation[5](21,4) = -3.0/64.0;
+  prolongation[5](21,5) = 9.0/64.0;
+  prolongation[5](21,6) = -3.0/64.0;
+  prolongation[5](21,7) = 1.0/64.0;
+  prolongation[5](21,12) = 9.0/32.0;
+  prolongation[5](21,13) = 9.0/32.0;
+  prolongation[5](21,14) = -3.0/32.0;
+  prolongation[5](21,15) = -3.0/32.0;
+  prolongation[5](21,21) = 9.0/16.0;
+  prolongation[5](22,0) = 1.0/64.0;
+  prolongation[5](22,1) = -3.0/64.0;
+  prolongation[5](22,4) = -3.0/64.0;
+  prolongation[5](22,5) = 9.0/64.0;
+  prolongation[5](22,8) = -3.0/32.0;
+  prolongation[5](22,12) = 9.0/32.0;
+  prolongation[5](22,16) = -3.0/32.0;
+  prolongation[5](22,17) = 9.0/32.0;
+  prolongation[5](22,22) = 9.0/16.0;
+  prolongation[5](23,1) = -3.0/64.0;
+  prolongation[5](23,2) = 1.0/64.0;
+  prolongation[5](23,5) = 9.0/64.0;
+  prolongation[5](23,6) = -3.0/64.0;
+  prolongation[5](23,9) = -3.0/32.0;
+  prolongation[5](23,13) = 9.0/32.0;
+  prolongation[5](23,17) = 9.0/32.0;
+  prolongation[5](23,18) = -3.0/32.0;
+  prolongation[5](23,23) = 9.0/16.0;
+  prolongation[5](24,9) = -3.0/64.0;
+  prolongation[5](24,11) = 1.0/64.0;
+  prolongation[5](24,13) = 9.0/64.0;
+  prolongation[5](24,15) = -3.0/64.0;
+  prolongation[5](24,20) = -3.0/32.0;
+  prolongation[5](24,21) = 9.0/32.0;
+  prolongation[5](24,23) = 9.0/32.0;
+  prolongation[5](24,25) = -3.0/32.0;
+  prolongation[5](24,26) = 9.0/16.0;
+  prolongation[5](25,8) = -3.0/64.0;
+  prolongation[5](25,10) = 1.0/64.0;
+  prolongation[5](25,12) = 9.0/64.0;
+  prolongation[5](25,14) = -3.0/64.0;
+  prolongation[5](25,20) = -3.0/32.0;
+  prolongation[5](25,21) = 9.0/32.0;
+  prolongation[5](25,22) = 9.0/32.0;
+  prolongation[5](25,24) = -3.0/32.0;
+  prolongation[5](25,26) = 9.0/16.0;
+  prolongation[5](26,0) = 3.0/512.0;
+  prolongation[5](26,1) = -9.0/512.0;
+  prolongation[5](26,2) = 3.0/512.0;
+  prolongation[5](26,3) = -1.0/512.0;
+  prolongation[5](26,4) = -9.0/512.0;
+  prolongation[5](26,5) = 27.0/512.0;
+  prolongation[5](26,6) = -9.0/512.0;
+  prolongation[5](26,7) = 3.0/512.0;
+  prolongation[5](26,8) = -9.0/256.0;
+  prolongation[5](26,9) = -9.0/256.0;
+  prolongation[5](26,10) = 3.0/256.0;
+  prolongation[5](26,11) = 3.0/256.0;
+  prolongation[5](26,12) = 27.0/256.0;
+  prolongation[5](26,13) = 27.0/256.0;
+  prolongation[5](26,14) = -9.0/256.0;
+  prolongation[5](26,15) = -9.0/256.0;
+  prolongation[5](26,16) = -9.0/256.0;
+  prolongation[5](26,17) = 27.0/256.0;
+  prolongation[5](26,18) = -9.0/256.0;
+  prolongation[5](26,19) = 3.0/256.0;
+  prolongation[5](26,20) = -9.0/128.0;
+  prolongation[5](26,21) = 27.0/128.0;
+  prolongation[5](26,22) = 27.0/128.0;
+  prolongation[5](26,23) = 27.0/128.0;
+  prolongation[5](26,24) = -9.0/128.0;
+  prolongation[5](26,25) = -9.0/128.0;
+  prolongation[5](26,26) = 27.0/64.0;
+  prolongation[6](0,26) = 1.0;
+  prolongation[6](1,23) = 1.0;
+  prolongation[6](2,18) = 1.0;
+  prolongation[6](3,24) = 1.0;
+  prolongation[6](4,21) = 1.0;
+  prolongation[6](5,13) = 1.0;
+  prolongation[6](6,6) = 1.0;
+  prolongation[6](7,14) = 1.0;
+  prolongation[6](8,23) = 3.0/8.0;
+  prolongation[6](8,25) = -1.0/8.0;
+  prolongation[6](8,26) = 3.0/4.0;
+  prolongation[6](9,17) = -1.0/8.0;
+  prolongation[6](9,18) = 3.0/8.0;
+  prolongation[6](9,23) = 3.0/4.0;
+  prolongation[6](10,18) = 3.0/8.0;
+  prolongation[6](10,19) = -1.0/8.0;
+  prolongation[6](10,24) = 3.0/4.0;
+  prolongation[6](11,22) = -1.0/8.0;
+  prolongation[6](11,24) = 3.0/8.0;
+  prolongation[6](11,26) = 3.0/4.0;
+  prolongation[6](12,13) = 3.0/8.0;
+  prolongation[6](12,15) = -1.0/8.0;
+  prolongation[6](12,21) = 3.0/4.0;
+  prolongation[6](13,5) = -1.0/8.0;
+  prolongation[6](13,6) = 3.0/8.0;
+  prolongation[6](13,13) = 3.0/4.0;
+  prolongation[6](14,6) = 3.0/8.0;
+  prolongation[6](14,7) = -1.0/8.0;
+  prolongation[6](14,14) = 3.0/4.0;
+  prolongation[6](15,12) = -1.0/8.0;
+  prolongation[6](15,14) = 3.0/8.0;
+  prolongation[6](15,21) = 3.0/4.0;
+  prolongation[6](16,20) = -1.0/8.0;
+  prolongation[6](16,21) = 3.0/8.0;
+  prolongation[6](16,26) = 3.0/4.0;
+  prolongation[6](17,9) = -1.0/8.0;
+  prolongation[6](17,13) = 3.0/8.0;
+  prolongation[6](17,23) = 3.0/4.0;
+  prolongation[6](18,2) = -1.0/8.0;
+  prolongation[6](18,6) = 3.0/8.0;
+  prolongation[6](18,18) = 3.0/4.0;
+  prolongation[6](19,10) = -1.0/8.0;
+  prolongation[6](19,14) = 3.0/8.0;
+  prolongation[6](19,24) = 3.0/4.0;
+  prolongation[6](20,16) = 1.0/64.0;
+  prolongation[6](20,17) = -3.0/64.0;
+  prolongation[6](20,18) = 9.0/64.0;
+  prolongation[6](20,19) = -3.0/64.0;
+  prolongation[6](20,22) = -3.0/32.0;
+  prolongation[6](20,23) = 9.0/32.0;
+  prolongation[6](20,24) = 9.0/32.0;
+  prolongation[6](20,25) = -3.0/32.0;
+  prolongation[6](20,26) = 9.0/16.0;
+  prolongation[6](21,4) = 1.0/64.0;
+  prolongation[6](21,5) = -3.0/64.0;
+  prolongation[6](21,6) = 9.0/64.0;
+  prolongation[6](21,7) = -3.0/64.0;
+  prolongation[6](21,12) = -3.0/32.0;
+  prolongation[6](21,13) = 9.0/32.0;
+  prolongation[6](21,14) = 9.0/32.0;
+  prolongation[6](21,15) = -3.0/32.0;
+  prolongation[6](21,21) = 9.0/16.0;
+  prolongation[6](22,9) = -3.0/64.0;
+  prolongation[6](22,11) = 1.0/64.0;
+  prolongation[6](22,13) = 9.0/64.0;
+  prolongation[6](22,15) = -3.0/64.0;
+  prolongation[6](22,20) = -3.0/32.0;
+  prolongation[6](22,21) = 9.0/32.0;
+  prolongation[6](22,23) = 9.0/32.0;
+  prolongation[6](22,25) = -3.0/32.0;
+  prolongation[6](22,26) = 9.0/16.0;
+  prolongation[6](23,1) = 1.0/64.0;
+  prolongation[6](23,2) = -3.0/64.0;
+  prolongation[6](23,5) = -3.0/64.0;
+  prolongation[6](23,6) = 9.0/64.0;
+  prolongation[6](23,9) = -3.0/32.0;
+  prolongation[6](23,13) = 9.0/32.0;
+  prolongation[6](23,17) = -3.0/32.0;
+  prolongation[6](23,18) = 9.0/32.0;
+  prolongation[6](23,23) = 9.0/16.0;
+  prolongation[6](24,2) = -3.0/64.0;
+  prolongation[6](24,3) = 1.0/64.0;
+  prolongation[6](24,6) = 9.0/64.0;
+  prolongation[6](24,7) = -3.0/64.0;
+  prolongation[6](24,10) = -3.0/32.0;
+  prolongation[6](24,14) = 9.0/32.0;
+  prolongation[6](24,18) = 9.0/32.0;
+  prolongation[6](24,19) = -3.0/32.0;
+  prolongation[6](24,24) = 9.0/16.0;
+  prolongation[6](25,8) = 1.0/64.0;
+  prolongation[6](25,10) = -3.0/64.0;
+  prolongation[6](25,12) = -3.0/64.0;
+  prolongation[6](25,14) = 9.0/64.0;
+  prolongation[6](25,20) = -3.0/32.0;
+  prolongation[6](25,21) = 9.0/32.0;
+  prolongation[6](25,22) = -3.0/32.0;
+  prolongation[6](25,24) = 9.0/32.0;
+  prolongation[6](25,26) = 9.0/16.0;
+  prolongation[6](26,0) = -1.0/512.0;
+  prolongation[6](26,1) = 3.0/512.0;
+  prolongation[6](26,2) = -9.0/512.0;
+  prolongation[6](26,3) = 3.0/512.0;
+  prolongation[6](26,4) = 3.0/512.0;
+  prolongation[6](26,5) = -9.0/512.0;
+  prolongation[6](26,6) = 27.0/512.0;
+  prolongation[6](26,7) = -9.0/512.0;
+  prolongation[6](26,8) = 3.0/256.0;
+  prolongation[6](26,9) = -9.0/256.0;
+  prolongation[6](26,10) = -9.0/256.0;
+  prolongation[6](26,11) = 3.0/256.0;
+  prolongation[6](26,12) = -9.0/256.0;
+  prolongation[6](26,13) = 27.0/256.0;
+  prolongation[6](26,14) = 27.0/256.0;
+  prolongation[6](26,15) = -9.0/256.0;
+  prolongation[6](26,16) = 3.0/256.0;
+  prolongation[6](26,17) = -9.0/256.0;
+  prolongation[6](26,18) = 27.0/256.0;
+  prolongation[6](26,19) = -9.0/256.0;
+  prolongation[6](26,20) = -9.0/128.0;
+  prolongation[6](26,21) = 27.0/128.0;
+  prolongation[6](26,22) = -9.0/128.0;
+  prolongation[6](26,23) = 27.0/128.0;
+  prolongation[6](26,24) = 27.0/128.0;
+  prolongation[6](26,25) = -9.0/128.0;
+  prolongation[6](26,26) = 27.0/64.0;
+  prolongation[7](0,25) = 1.0;
+  prolongation[7](1,26) = 1.0;
+  prolongation[7](2,24) = 1.0;
+  prolongation[7](3,19) = 1.0;
+  prolongation[7](4,15) = 1.0;
+  prolongation[7](5,21) = 1.0;
+  prolongation[7](6,14) = 1.0;
+  prolongation[7](7,7) = 1.0;
+  prolongation[7](8,23) = -1.0/8.0;
+  prolongation[7](8,25) = 3.0/8.0;
+  prolongation[7](8,26) = 3.0/4.0;
+  prolongation[7](9,22) = -1.0/8.0;
+  prolongation[7](9,24) = 3.0/8.0;
+  prolongation[7](9,26) = 3.0/4.0;
+  prolongation[7](10,18) = -1.0/8.0;
+  prolongation[7](10,19) = 3.0/8.0;
+  prolongation[7](10,24) = 3.0/4.0;
+  prolongation[7](11,16) = -1.0/8.0;
+  prolongation[7](11,19) = 3.0/8.0;
+  prolongation[7](11,25) = 3.0/4.0;
+  prolongation[7](12,13) = -1.0/8.0;
+  prolongation[7](12,15) = 3.0/8.0;
+  prolongation[7](12,21) = 3.0/4.0;
+  prolongation[7](13,12) = -1.0/8.0;
+  prolongation[7](13,14) = 3.0/8.0;
+  prolongation[7](13,21) = 3.0/4.0;
+  prolongation[7](14,6) = -1.0/8.0;
+  prolongation[7](14,7) = 3.0/8.0;
+  prolongation[7](14,14) = 3.0/4.0;
+  prolongation[7](15,4) = -1.0/8.0;
+  prolongation[7](15,7) = 3.0/8.0;
+  prolongation[7](15,15) = 3.0/4.0;
+  prolongation[7](16,11) = -1.0/8.0;
+  prolongation[7](16,15) = 3.0/8.0;
+  prolongation[7](16,25) = 3.0/4.0;
+  prolongation[7](17,20) = -1.0/8.0;
+  prolongation[7](17,21) = 3.0/8.0;
+  prolongation[7](17,26) = 3.0/4.0;
+  prolongation[7](18,10) = -1.0/8.0;
+  prolongation[7](18,14) = 3.0/8.0;
+  prolongation[7](18,24) = 3.0/4.0;
+  prolongation[7](19,3) = -1.0/8.0;
+  prolongation[7](19,7) = 3.0/8.0;
+  prolongation[7](19,19) = 3.0/4.0;
+  prolongation[7](20,16) = -3.0/64.0;
+  prolongation[7](20,17) = 1.0/64.0;
+  prolongation[7](20,18) = -3.0/64.0;
+  prolongation[7](20,19) = 9.0/64.0;
+  prolongation[7](20,22) = -3.0/32.0;
+  prolongation[7](20,23) = -3.0/32.0;
+  prolongation[7](20,24) = 9.0/32.0;
+  prolongation[7](20,25) = 9.0/32.0;
+  prolongation[7](20,26) = 9.0/16.0;
+  prolongation[7](21,4) = -3.0/64.0;
+  prolongation[7](21,5) = 1.0/64.0;
+  prolongation[7](21,6) = -3.0/64.0;
+  prolongation[7](21,7) = 9.0/64.0;
+  prolongation[7](21,12) = -3.0/32.0;
+  prolongation[7](21,13) = -3.0/32.0;
+  prolongation[7](21,14) = 9.0/32.0;
+  prolongation[7](21,15) = 9.0/32.0;
+  prolongation[7](21,21) = 9.0/16.0;
+  prolongation[7](22,9) = 1.0/64.0;
+  prolongation[7](22,11) = -3.0/64.0;
+  prolongation[7](22,13) = -3.0/64.0;
+  prolongation[7](22,15) = 9.0/64.0;
+  prolongation[7](22,20) = -3.0/32.0;
+  prolongation[7](22,21) = 9.0/32.0;
+  prolongation[7](22,23) = -3.0/32.0;
+  prolongation[7](22,25) = 9.0/32.0;
+  prolongation[7](22,26) = 9.0/16.0;
+  prolongation[7](23,8) = 1.0/64.0;
+  prolongation[7](23,10) = -3.0/64.0;
+  prolongation[7](23,12) = -3.0/64.0;
+  prolongation[7](23,14) = 9.0/64.0;
+  prolongation[7](23,20) = -3.0/32.0;
+  prolongation[7](23,21) = 9.0/32.0;
+  prolongation[7](23,22) = -3.0/32.0;
+  prolongation[7](23,24) = 9.0/32.0;
+  prolongation[7](23,26) = 9.0/16.0;
+  prolongation[7](24,2) = 1.0/64.0;
+  prolongation[7](24,3) = -3.0/64.0;
+  prolongation[7](24,6) = -3.0/64.0;
+  prolongation[7](24,7) = 9.0/64.0;
+  prolongation[7](24,10) = -3.0/32.0;
+  prolongation[7](24,14) = 9.0/32.0;
+  prolongation[7](24,18) = -3.0/32.0;
+  prolongation[7](24,19) = 9.0/32.0;
+  prolongation[7](24,24) = 9.0/16.0;
+  prolongation[7](25,0) = 1.0/64.0;
+  prolongation[7](25,3) = -3.0/64.0;
+  prolongation[7](25,4) = -3.0/64.0;
+  prolongation[7](25,7) = 9.0/64.0;
+  prolongation[7](25,11) = -3.0/32.0;
+  prolongation[7](25,15) = 9.0/32.0;
+  prolongation[7](25,16) = -3.0/32.0;
+  prolongation[7](25,19) = 9.0/32.0;
+  prolongation[7](25,25) = 9.0/16.0;
+  prolongation[7](26,0) = 3.0/512.0;
+  prolongation[7](26,1) = -1.0/512.0;
+  prolongation[7](26,2) = 3.0/512.0;
+  prolongation[7](26,3) = -9.0/512.0;
+  prolongation[7](26,4) = -9.0/512.0;
+  prolongation[7](26,5) = 3.0/512.0;
+  prolongation[7](26,6) = -9.0/512.0;
+  prolongation[7](26,7) = 27.0/512.0;
+  prolongation[7](26,8) = 3.0/256.0;
+  prolongation[7](26,9) = 3.0/256.0;
+  prolongation[7](26,10) = -9.0/256.0;
+  prolongation[7](26,11) = -9.0/256.0;
+  prolongation[7](26,12) = -9.0/256.0;
+  prolongation[7](26,13) = -9.0/256.0;
+  prolongation[7](26,14) = 27.0/256.0;
+  prolongation[7](26,15) = 27.0/256.0;
+  prolongation[7](26,16) = -9.0/256.0;
+  prolongation[7](26,17) = 3.0/256.0;
+  prolongation[7](26,18) = -9.0/256.0;
+  prolongation[7](26,19) = 27.0/256.0;
+  prolongation[7](26,20) = -9.0/128.0;
+  prolongation[7](26,21) = 27.0/128.0;
+  prolongation[7](26,22) = -9.0/128.0;
+  prolongation[7](26,23) = -9.0/128.0;
+  prolongation[7](26,24) = 27.0/128.0;
+  prolongation[7](26,25) = 27.0/128.0;
+  prolongation[7](26,26) = 27.0/64.0;
+
+  restriction[0](0,0) = 1.0;
+  restriction[0](8,1) = 1.0;
+  restriction[0](11,3) = 1.0;
+  restriction[0](16,4) = 1.0;
+  restriction[0](20,2) = 1.0;
+  restriction[0](22,5) = 1.0;
+  restriction[0](25,7) = 1.0;
+  restriction[0](26,6) = 1.0;
+  restriction[1](1,1) = 1.0;
+  restriction[1](8,0) = 1.0;
+  restriction[1](9,2) = 1.0;
+  restriction[1](17,5) = 1.0;
+  restriction[1](20,3) = 1.0;
+  restriction[1](22,4) = 1.0;
+  restriction[1](23,6) = 1.0;
+  restriction[1](26,7) = 1.0;
+  restriction[2](2,2) = 1.0;
+  restriction[2](9,1) = 1.0;
+  restriction[2](10,3) = 1.0;
+  restriction[2](18,6) = 1.0;
+  restriction[2](20,0) = 1.0;
+  restriction[2](23,5) = 1.0;
+  restriction[2](24,7) = 1.0;
+  restriction[2](26,4) = 1.0;
+  restriction[3](3,3) = 1.0;
+  restriction[3](10,2) = 1.0;
+  restriction[3](11,0) = 1.0;
+  restriction[3](19,7) = 1.0;
+  restriction[3](20,1) = 1.0;
+  restriction[3](24,6) = 1.0;
+  restriction[3](25,4) = 1.0;
+  restriction[3](26,5) = 1.0;
+  restriction[4](4,4) = 1.0;
+  restriction[4](12,5) = 1.0;
+  restriction[4](15,7) = 1.0;
+  restriction[4](16,0) = 1.0;
+  restriction[4](21,6) = 1.0;
+  restriction[4](22,1) = 1.0;
+  restriction[4](25,3) = 1.0;
+  restriction[4](26,2) = 1.0;
+  restriction[5](5,5) = 1.0;
+  restriction[5](12,4) = 1.0;
+  restriction[5](13,6) = 1.0;
+  restriction[5](17,1) = 1.0;
+  restriction[5](21,7) = 1.0;
+  restriction[5](22,0) = 1.0;
+  restriction[5](23,2) = 1.0;
+  restriction[5](26,3) = 1.0;
+  restriction[6](6,6) = 1.0;
+  restriction[6](13,5) = 1.0;
+  restriction[6](14,7) = 1.0;
+  restriction[6](18,2) = 1.0;
+  restriction[6](21,4) = 1.0;
+  restriction[6](23,1) = 1.0;
+  restriction[6](24,3) = 1.0;
+  restriction[6](26,0) = 1.0;
+  restriction[7](7,7) = 1.0;
+  restriction[7](14,6) = 1.0;
+  restriction[7](15,4) = 1.0;
+  restriction[7](19,3) = 1.0;
+  restriction[7](21,5) = 1.0;
+  restriction[7](24,2) = 1.0;
+  restriction[7](25,0) = 1.0;
+  restriction[7](26,1) = 1.0;
+};
+
+
+
+template <>
+double
+FEQuadraticSub<3>::shape_value (const unsigned int i,
+                               const Point<3>    &p) const
+{
+  Assert (i<total_dofs, ExcInvalidIndex(i));
+
+  const double xi  = p(0),
+              eta = p(1),
+              zeta=p(2);
+  switch (i)
+    {
+      case 0: return 1.0-3.0*xi+2.0*xi*xi+(-3.0+9.0*xi-6.0*xi*xi)*eta+(2.0
+-6.0*xi+4.0*xi*xi)*eta*eta+(-3.0+9.0*xi-6.0*xi*xi+(9.0-27.0*xi+18.0*xi*xi)*eta+
+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta)*zeta+(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi
+-12.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 1: return -xi+2.0*xi*xi+(3.0*xi-6.0*xi*xi)*eta+(-2.0*xi+4.0*xi*xi)
+*eta*eta+(3.0*xi-6.0*xi*xi+(-9.0*xi+18.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta
+)*zeta+(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*
+zeta*zeta;
+      case 2: return (xi-2.0*xi*xi+(-3.0*xi+6.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)
+*eta*eta)*zeta+(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*
+eta*eta)*zeta*zeta;
+      case 3: return (-1.0+3.0*xi-2.0*xi*xi+(3.0-9.0*xi+6.0*xi*xi)*eta+(-2.0+
+6.0*xi-4.0*xi*xi)*eta*eta)*zeta+(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi-12.0*xi*xi)
+*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 4: return (-1.0+3.0*xi-2.0*xi*xi)*eta+(2.0-6.0*xi+4.0*xi*xi)*eta*
+eta+((3.0-9.0*xi+6.0*xi*xi)*eta+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta)*zeta+((-2.0+
+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 5: return (xi-2.0*xi*xi)*eta+(-2.0*xi+4.0*xi*xi)*eta*eta+((-3.0*xi
++6.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta)*zeta+((2.0*xi-4.0*xi*xi)*eta+(-4.0
+*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 6: return ((-xi+2.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)*eta*eta)*zeta+((
+2.0*xi-4.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 7: return ((1.0-3.0*xi+2.0*xi*xi)*eta+(-2.0+6.0*xi-4.0*xi*xi)*eta*
+eta)*zeta+((-2.0+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*
+zeta;
+      case 8: return 4.0*xi-4.0*xi*xi+(-12.0*xi+12.0*xi*xi)*eta+(8.0*xi-8.0*
+xi*xi)*eta*eta+(-12.0*xi+12.0*xi*xi+(36.0*xi-36.0*xi*xi)*eta+(-24.0*xi+24.0*xi*
+xi)*eta*eta)*zeta+(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi-16.0*xi*
+xi)*eta*eta)*zeta*zeta;
+      case 9: return (-4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*eta+(-8.0*xi+
+16.0*xi*xi)*eta*eta)*zeta+(4.0*xi-8.0*xi*xi+(-12.0*xi+24.0*xi*xi)*eta+(8.0*xi
+-16.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 10: return (-4.0*xi+4.0*xi*xi+(12.0*xi-12.0*xi*xi)*eta+(-8.0*xi+
+8.0*xi*xi)*eta*eta)*zeta+(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi
+-16.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 11: return (4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*eta+(
+8.0-24.0*xi+16.0*xi*xi)*eta*eta)*zeta+(-4.0+12.0*xi-8.0*xi*xi+(12.0-36.0*xi+
+24.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 12: return (-4.0*xi+4.0*xi*xi)*eta+(8.0*xi-8.0*xi*xi)*eta*eta+((
+12.0*xi-12.0*xi*xi)*eta+(-24.0*xi+24.0*xi*xi)*eta*eta)*zeta+((-8.0*xi+8.0*xi*xi
+)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 13: return ((4.0*xi-8.0*xi*xi)*eta+(-8.0*xi+16.0*xi*xi)*eta*eta)*
+zeta+((-4.0*xi+8.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 14: return ((4.0*xi-4.0*xi*xi)*eta+(-8.0*xi+8.0*xi*xi)*eta*eta)*
+zeta+((-8.0*xi+8.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 15: return ((-4.0+12.0*xi-8.0*xi*xi)*eta+(8.0-24.0*xi+16.0*xi*xi)*
+eta*eta)*zeta+((4.0-12.0*xi+8.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*
+zeta*zeta;
+      case 16: return (4.0-12.0*xi+8.0*xi*xi)*eta+(-4.0+12.0*xi-8.0*xi*xi)*
+eta*eta+((-12.0+36.0*xi-24.0*xi*xi)*eta+(12.0-36.0*xi+24.0*xi*xi)*eta*eta)*zeta
++((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 17: return (-4.0*xi+8.0*xi*xi)*eta+(4.0*xi-8.0*xi*xi)*eta*eta+((
+12.0*xi-24.0*xi*xi)*eta+(-12.0*xi+24.0*xi*xi)*eta*eta)*zeta+((-8.0*xi+16.0*xi*
+xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 18: return ((4.0*xi-8.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*
+zeta+((-8.0*xi+16.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 19: return ((-4.0+12.0*xi-8.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*
+eta*eta)*zeta+((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*
+zeta*zeta;
+      case 20: return (16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*eta+(32.0*xi
+-32.0*xi*xi)*eta*eta)*zeta+(-16.0*xi+16.0*xi*xi+(48.0*xi-48.0*xi*xi)*eta+(-32.0
+*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 21: return ((-16.0*xi+16.0*xi*xi)*eta+(32.0*xi-32.0*xi*xi)*eta*eta
+)*zeta+((16.0*xi-16.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 22: return (16.0*xi-16.0*xi*xi)*eta+(-16.0*xi+16.0*xi*xi)*eta*eta+
+((-48.0*xi+48.0*xi*xi)*eta+(48.0*xi-48.0*xi*xi)*eta*eta)*zeta+((32.0*xi-32.0*xi
+*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 23: return ((-16.0*xi+32.0*xi*xi)*eta+(16.0*xi-32.0*xi*xi)*eta*eta
+)*zeta+((16.0*xi-32.0*xi*xi)*eta+(-16.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 24: return ((-16.0*xi+16.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta
+)*zeta+((32.0*xi-32.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+      case 25: return ((16.0-48.0*xi+32.0*xi*xi)*eta+(-16.0+48.0*xi-32.0*xi*
+xi)*eta*eta)*zeta+((-16.0+48.0*xi-32.0*xi*xi)*eta+(16.0-48.0*xi+32.0*xi*xi)*eta
+*eta)*zeta*zeta;
+      case 26: return ((64.0*xi-64.0*xi*xi)*eta+(-64.0*xi+64.0*xi*xi)*eta*eta
+)*zeta+((-64.0*xi+64.0*xi*xi)*eta+(64.0*xi-64.0*xi*xi)*eta*eta)*zeta*zeta;
+    };
+  return 0;
+};
 
 
+
+template <>
+Tensor<1,3>
+FEQuadraticSub<3>::shape_grad (const unsigned int i,
+                              const Point<3>    &p) const
+{
+  Assert (i<total_dofs, ExcInvalidIndex(i));
+
+  const double xi  = p(0),
+              eta = p(1),
+              zeta=p(2);
+                                  // originally, the return type of the
+                                  // function was Point<dim>, so we
+                                  // still construct it as that. it should
+                                  // make no difference in practice,
+                                  // however
+  switch (i)
+    {
+      case 0: return Point<3>(-3.0+4.0*xi+(9.0-12.0*xi)*eta+(-6.0+8.0*xi)*eta*eta+(9.0-12.0*xi+(-27.0+36.0*xi)*eta+(18.0-24.0*xi)*eta*eta)*zeta+(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta*zeta,
+      -3.0+9.0*xi-6.0*xi*xi+2.0*(2.0-6.0*xi+4.0*xi*xi)*eta+(9.0-27.0*xi+18.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta)*zeta+(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+      -3.0+9.0*xi-6.0*xi*xi+(9.0-27.0*xi+18.0*xi*xi)*eta+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta+2.0*(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi-12.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+      case 1: return Point<3>(-1.0+4.0*xi+(3.0-12.0*xi)*eta+(-2.0+8.0*xi)*eta*eta+(3.0-12.0*xi+(-9.0+36.0*xi)*eta+(6.0-24.0*xi)*eta*eta)*zeta+(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta*zeta,
+      3.0*xi-6.0*xi*xi+2.0*(-2.0*xi+4.0*xi*xi)*eta+(-9.0*xi+18.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta)*zeta+(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+      3.0*xi-6.0*xi*xi+(-9.0*xi+18.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta+2.0*(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+      case 2: return Point<3>((1.0-4.0*xi+(-3.0+12.0*xi)*eta+(2.0-8.0*xi)*eta*eta)*zeta+(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta*zeta,
+      (-3.0*xi+6.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta)*zeta+(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+      xi-2.0*xi*xi+(-3.0*xi+6.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)*eta*eta+2.0*(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+      case 3: return Point<3>((3.0-4.0*xi+(-9.0+12.0*xi)*eta+(6.0-8.0*xi)*eta*eta)*zeta+(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta*zeta,
+      (3.0-9.0*xi+6.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta)*zeta+(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+      -1.0+3.0*xi-2.0*xi*xi+(3.0-9.0*xi+6.0*xi*xi)*eta+(-2.0+6.0*xi-4.0*xi*xi)*eta*eta+2.0*(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi-12.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+      case 4: return Point<3>((3.0-4.0*xi)*eta+(-6.0+8.0*xi)*eta*eta+((-9.0+12.0*xi)*eta+(18.0-24.0*xi)*eta*eta)*zeta+((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta*zeta,
+      -1.0+3.0*xi-2.0*xi*xi+2.0*(2.0-6.0*xi+4.0*xi*xi)*eta+(3.0-9.0*xi+6.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta)*zeta+(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+      (3.0-9.0*xi+6.0*xi*xi)*eta+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta+2.0*((-2.0+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+      case 5: return Point<3>((1.0-4.0*xi)*eta+(-2.0+8.0*xi)*eta*eta+((-3.0+12.0*xi)*eta+(6.0-24.0*xi)*eta*eta)*zeta+((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta*zeta,
+      xi-2.0*xi*xi+2.0*(-2.0*xi+4.0*xi*xi)*eta+(-3.0*xi+6.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta)*zeta+(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+      (-3.0*xi+6.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta+2.0*((2.0*xi-4.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+      case 6: return Point<3>(((-1.0+4.0*xi)*eta+(2.0-8.0*xi)*eta*eta)*zeta+((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta*zeta,
+      (-xi+2.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta)*zeta+(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+      (-xi+2.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)*eta*eta+2.0*((2.0*xi-4.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+      case 7: return Point<3>(((-3.0+4.0*xi)*eta+(6.0-8.0*xi)*eta*eta)*zeta+((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta*zeta,
+      (1.0-3.0*xi+2.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta)*zeta+(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+      (1.0-3.0*xi+2.0*xi*xi)*eta+(-2.0+6.0*xi-4.0*xi*xi)*eta*eta+2.0*((-2.0+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+      case 8: return Point<3>(4.0-8.0*xi+(-12.0+24.0*xi)*eta+(8.0-16.0*xi)*eta*eta+(-12.0+24.0*xi+(36.0-72.0*xi)*eta+(-24.0+48.0*xi)*eta*eta)*zeta+(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta*zeta,
+      -12.0*xi+12.0*xi*xi+2.0*(8.0*xi-8.0*xi*xi)*eta+(36.0*xi-36.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta)*zeta+(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      -12.0*xi+12.0*xi*xi+(36.0*xi-36.0*xi*xi)*eta+(-24.0*xi+24.0*xi*xi)*eta*eta+2.0*(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 9: return Point<3>((-4.0+16.0*xi+(12.0-48.0*xi)*eta+(-8.0+32.0*xi)*eta*eta)*zeta+(4.0-16.0*xi+(-12.0+48.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta*zeta,
+      (12.0*xi-24.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta)*zeta+(-12.0*xi+24.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      -4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*eta+(-8.0*xi+16.0*xi*xi)*eta*eta+2.0*(4.0*xi-8.0*xi*xi+(-12.0*xi+24.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 10: return Point<3>((-4.0+8.0*xi+(12.0-24.0*xi)*eta+(-8.0+16.0*xi)*eta*eta)*zeta+(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta*zeta,
+      (12.0*xi-12.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta)*zeta+(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      -4.0*xi+4.0*xi*xi+(12.0*xi-12.0*xi*xi)*eta+(-8.0*xi+8.0*xi*xi)*eta*eta+2.0*(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 11: return Point<3>((-12.0+16.0*xi+(36.0-48.0*xi)*eta+(-24.0+32.0*xi)*eta*eta)*zeta+(12.0-16.0*xi+(-36.0+48.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta*zeta,
+      (-12.0+36.0*xi-24.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta)*zeta+(12.0-36.0*xi+24.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*eta+(8.0-24.0*xi+16.0*xi*xi)*eta*eta+2.0*(-4.0+12.0*xi-8.0*xi*xi+(12.0-36.0*xi+24.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 12: return Point<3>((-4.0+8.0*xi)*eta+(8.0-16.0*xi)*eta*eta+((12.0-24.0*xi)*eta+(-24.0+48.0*xi)*eta*eta)*zeta+((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta*zeta,
+      -4.0*xi+4.0*xi*xi+2.0*(8.0*xi-8.0*xi*xi)*eta+(12.0*xi-12.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta)*zeta+(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      (12.0*xi-12.0*xi*xi)*eta+(-24.0*xi+24.0*xi*xi)*eta*eta+2.0*((-8.0*xi+8.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 13: return Point<3>(((4.0-16.0*xi)*eta+(-8.0+32.0*xi)*eta*eta)*zeta+((-4.0+16.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta*zeta,
+      (4.0*xi-8.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta)*zeta+(-4.0*xi+8.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      (4.0*xi-8.0*xi*xi)*eta+(-8.0*xi+16.0*xi*xi)*eta*eta+2.0*((-4.0*xi+8.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 14: return Point<3>(((4.0-8.0*xi)*eta+(-8.0+16.0*xi)*eta*eta)*zeta+((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta*zeta,
+      (4.0*xi-4.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta)*zeta+(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      (4.0*xi-4.0*xi*xi)*eta+(-8.0*xi+8.0*xi*xi)*eta*eta+2.0*((-8.0*xi+8.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 15: return Point<3>(((12.0-16.0*xi)*eta+(-24.0+32.0*xi)*eta*eta)*zeta+((-12.0+16.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta*zeta,
+      (-4.0+12.0*xi-8.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta)*zeta+(4.0-12.0*xi+8.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      (-4.0+12.0*xi-8.0*xi*xi)*eta+(8.0-24.0*xi+16.0*xi*xi)*eta*eta+2.0*((4.0-12.0*xi+8.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 16: return Point<3>((-12.0+16.0*xi)*eta+(12.0-16.0*xi)*eta*eta+((36.0-48.0*xi)*eta+(-36.0+48.0*xi)*eta*eta)*zeta+((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta*zeta,
+      4.0-12.0*xi+8.0*xi*xi+2.0*(-4.0+12.0*xi-8.0*xi*xi)*eta+(-12.0+36.0*xi-24.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta)*zeta+(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      (-12.0+36.0*xi-24.0*xi*xi)*eta+(12.0-36.0*xi+24.0*xi*xi)*eta*eta+2.0*((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 17: return Point<3>((-4.0+16.0*xi)*eta+(4.0-16.0*xi)*eta*eta+((12.0-48.0*xi)*eta+(-12.0+48.0*xi)*eta*eta)*zeta+((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta*zeta,
+      -4.0*xi+8.0*xi*xi+2.0*(4.0*xi-8.0*xi*xi)*eta+(12.0*xi-24.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta)*zeta+(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      (12.0*xi-24.0*xi*xi)*eta+(-12.0*xi+24.0*xi*xi)*eta*eta+2.0*((-8.0*xi+16.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 18: return Point<3>(((4.0-16.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta+((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta*zeta,
+      (4.0*xi-8.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta+(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      (4.0*xi-8.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta+2.0*((-8.0*xi+16.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 19: return Point<3>(((12.0-16.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta+((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta*zeta,
+      (-4.0+12.0*xi-8.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta+(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+      (-4.0+12.0*xi-8.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta+2.0*((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+      case 20: return Point<3>((16.0-32.0*xi+(-48.0+96.0*xi)*eta+(32.0-64.0*xi)*eta*eta)*zeta+(-16.0+32.0*xi+(48.0-96.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta*zeta,
+      (-48.0*xi+48.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta)*zeta+(48.0*xi-48.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+      16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*eta+(32.0*xi-32.0*xi*xi)*eta*eta+2.0*(-16.0*xi+16.0*xi*xi+(48.0*xi-48.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+      case 21: return Point<3>(((-16.0+32.0*xi)*eta+(32.0-64.0*xi)*eta*eta)*zeta+((16.0-32.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta*zeta,
+      (-16.0*xi+16.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta)*zeta+(16.0*xi-16.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+      (-16.0*xi+16.0*xi*xi)*eta+(32.0*xi-32.0*xi*xi)*eta*eta+2.0*((16.0*xi-16.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+      case 22: return Point<3>((16.0-32.0*xi)*eta+(-16.0+32.0*xi)*eta*eta+((-48.0+96.0*xi)*eta+(48.0-96.0*xi)*eta*eta)*zeta+((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta*zeta,
+      16.0*xi-16.0*xi*xi+2.0*(-16.0*xi+16.0*xi*xi)*eta+(-48.0*xi+48.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta)*zeta+(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+      (-48.0*xi+48.0*xi*xi)*eta+(48.0*xi-48.0*xi*xi)*eta*eta+2.0*((32.0*xi-32.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+      case 23: return Point<3>(((-16.0+64.0*xi)*eta+(16.0-64.0*xi)*eta*eta)*zeta+((16.0-64.0*xi)*eta+(-16.0+64.0*xi)*eta*eta)*zeta*zeta,
+      (-16.0*xi+32.0*xi*xi+2.0*(16.0*xi-32.0*xi*xi)*eta)*zeta+(16.0*xi-32.0*xi*xi+2.0*(-16.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+      (-16.0*xi+32.0*xi*xi)*eta+(16.0*xi-32.0*xi*xi)*eta*eta+2.0*((16.0*xi-32.0*xi*xi)*eta+(-16.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+      case 24: return Point<3>(((-16.0+32.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta+((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta*zeta,
+      (-16.0*xi+16.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta+(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+      (-16.0*xi+16.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta+2.0*((32.0*xi-32.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+      case 25: return Point<3>(((-48.0+64.0*xi)*eta+(48.0-64.0*xi)*eta*eta)*zeta+((48.0-64.0*xi)*eta+(-48.0+64.0*xi)*eta*eta)*zeta*zeta,
+      (16.0-48.0*xi+32.0*xi*xi+2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta)*zeta+(-16.0+48.0*xi-32.0*xi*xi+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+      (16.0-48.0*xi+32.0*xi*xi)*eta+(-16.0+48.0*xi-32.0*xi*xi)*eta*eta+2.0*((-16.0+48.0*xi-32.0*xi*xi)*eta+(16.0-48.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+      case 26: return Point<3>(((64.0-128.0*xi)*eta+(-64.0+128.0*xi)*eta*eta)*zeta+((-64.0+128.0*xi)*eta+(64.0-128.0*xi)*eta*eta)*zeta*zeta,
+      (64.0*xi-64.0*xi*xi+2.0*(-64.0*xi+64.0*xi*xi)*eta)*zeta+(-64.0*xi+64.0*xi*xi+2.0*(64.0*xi-64.0*xi*xi)*eta)*zeta*zeta,
+      (64.0*xi-64.0*xi*xi)*eta+(-64.0*xi+64.0*xi*xi)*eta*eta+2.0*((-64.0*xi+64.0*xi*xi)*eta+(64.0*xi-64.0*xi*xi)*eta*eta)*zeta);
+    };
+  return Point<3> ();
+};
+
+
+
+template <>
+Tensor<2,3>
+FEQuadraticSub<3>::shape_grad_grad (const unsigned int i,
+                                   const Point<3>    &p) const
+{
+  Assert (i<total_dofs, ExcInvalidIndex(i));
+
+  const double xi  = p(0),
+              eta = p(1),
+              zeta=p(2);
+  Tensor<2,3> return_value;
+  
+  switch (i)
+    {
+case 0:
+return_value[0][0] = 4.0-12.0*eta+8.0*eta*eta+(-12.0+36.0*eta-24.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
+return_value[0][1] = 9.0-12.0*xi+2.0*(-6.0+8.0*xi)*eta+(-27.0+36.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = 9.0-12.0*xi+(-27.0+36.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+return_value[1][0] = 9.0-12.0*xi+2.0*(-6.0+8.0*xi)*eta+(-27.0+36.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = 4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 9.0-27.0*xi+18.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][0] = 9.0-12.0*xi+(-27.0+36.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 9.0-27.0*xi+18.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 4.0-12.0*xi+8.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
+break;
+case 1:
+return_value[0][0] = 4.0-12.0*eta+8.0*eta*eta+(-12.0+36.0*eta-24.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
+return_value[0][1] = 3.0-12.0*xi+2.0*(-2.0+8.0*xi)*eta+(-9.0+36.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = 3.0-12.0*xi+(-9.0+36.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+return_value[1][0] = 3.0-12.0*xi+2.0*(-2.0+8.0*xi)*eta+(-9.0+36.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = -4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -9.0*xi+18.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][0] = 3.0-12.0*xi+(-9.0+36.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -9.0*xi+18.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][2] = -4.0*xi+8.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
+break;
+case 2:
+return_value[0][0] = (-4.0+12.0*eta-8.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (-3.0+12.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = 1.0-4.0*xi+(-3.0+12.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (-3.0+12.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (4.0*xi-8.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -3.0*xi+6.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][0] = 1.0-4.0*xi+(-3.0+12.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -3.0*xi+6.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][2] = -4.0*xi+8.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
+break;
+case 3:
+return_value[0][0] = (-4.0+12.0*eta-8.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (-9.0+12.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = 3.0-4.0*xi+(-9.0+12.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (-9.0+12.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (-4.0+12.0*xi-8.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][0] = 3.0-4.0*xi+(-9.0+12.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 4.0-12.0*xi+8.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
+break;
+case 4:
+return_value[0][0] = -4.0*eta+8.0*eta*eta+(12.0*eta-24.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
+return_value[0][1] = 3.0-4.0*xi+2.0*(-6.0+8.0*xi)*eta+(-9.0+12.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (-9.0+12.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+return_value[1][0] = 3.0-4.0*xi+2.0*(-6.0+8.0*xi)*eta+(-9.0+12.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = 4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (-9.0+12.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
+break;
+case 5:
+return_value[0][0] = -4.0*eta+8.0*eta*eta+(12.0*eta-24.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
+return_value[0][1] = 1.0-4.0*xi+2.0*(-2.0+8.0*xi)*eta+(-3.0+12.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (-3.0+12.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+return_value[1][0] = 1.0-4.0*xi+2.0*(-2.0+8.0*xi)*eta+(-3.0+12.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = -4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -3.0*xi+6.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (-3.0+12.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -3.0*xi+6.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
+break;
+case 6:
+return_value[0][0] = (4.0*eta-8.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (-1.0+4.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (-1.0+4.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (-1.0+4.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (4.0*xi-8.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -xi+2.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (-1.0+4.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -xi+2.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
+break;
+case 7:
+return_value[0][0] = (4.0*eta-8.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (-3.0+4.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (-3.0+4.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (-3.0+4.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (-4.0+12.0*xi-8.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 1.0-3.0*xi+2.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (-3.0+4.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 1.0-3.0*xi+2.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
+break;
+case 8:
+return_value[0][0] = -8.0+24.0*eta-16.0*eta*eta+(24.0-72.0*eta+48.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = -12.0+24.0*xi+2.0*(8.0-16.0*xi)*eta+(36.0-72.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = -12.0+24.0*xi+(36.0-72.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = -12.0+24.0*xi+2.0*(8.0-16.0*xi)*eta+(36.0-72.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = 16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 36.0*xi-36.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = -12.0+24.0*xi+(36.0-72.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 36.0*xi-36.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 16.0*xi-16.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
+break;
+case 9:
+return_value[0][0] = (16.0-48.0*eta+32.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (12.0-48.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-12.0+48.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = -4.0+16.0*xi+(12.0-48.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*(4.0-16.0*xi+(-12.0+48.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (12.0-48.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-12.0+48.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (-16.0*xi+32.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 12.0*xi-24.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-12.0*xi+24.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = -4.0+16.0*xi+(12.0-48.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*(4.0-16.0*xi+(-12.0+48.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 12.0*xi-24.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-12.0*xi+24.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 8.0*xi-16.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = (8.0-24.0*eta+16.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (12.0-24.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = -4.0+8.0*xi+(12.0-24.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (12.0-24.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (-16.0*xi+16.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 12.0*xi-12.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = -4.0+8.0*xi+(12.0-24.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 12.0*xi-12.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 16.0*xi-16.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = (16.0-48.0*eta+32.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (36.0-48.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-36.0+48.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = -12.0+16.0*xi+(36.0-48.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*(12.0-16.0*xi+(-36.0+48.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (36.0-48.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-36.0+48.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (16.0-48.0*xi+32.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -12.0+36.0*xi-24.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(12.0-36.0*xi+24.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = -12.0+16.0*xi+(36.0-48.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*(12.0-16.0*xi+(-36.0+48.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -12.0+36.0*xi-24.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(12.0-36.0*xi+24.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = -8.0+24.0*xi-16.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = 8.0*eta-16.0*eta*eta+(-24.0*eta+48.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = -4.0+8.0*xi+2.0*(8.0-16.0*xi)*eta+(12.0-24.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (12.0-24.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = -4.0+8.0*xi+2.0*(8.0-16.0*xi)*eta+(12.0-24.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = 16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 12.0*xi-12.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (12.0-24.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 12.0*xi-12.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = (-16.0*eta+32.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (4.0-16.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-4.0+16.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (4.0-16.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*((-4.0+16.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (4.0-16.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-4.0+16.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (-16.0*xi+32.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 4.0*xi-8.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (4.0-16.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*((-4.0+16.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 4.0*xi-8.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(-4.0*xi+8.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = (-8.0*eta+16.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (4.0-8.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (4.0-8.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (4.0-8.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (-16.0*xi+16.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 4.0*xi-4.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (4.0-8.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 4.0*xi-4.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = (-16.0*eta+32.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (12.0-16.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-12.0+16.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (12.0-16.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*((-12.0+16.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (12.0-16.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-12.0+16.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (16.0-48.0*xi+32.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -4.0+12.0*xi-8.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (12.0-16.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*((-12.0+16.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -4.0+12.0*xi-8.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(4.0-12.0*xi+8.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = 16.0*eta-16.0*eta*eta+(-48.0*eta+48.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = -12.0+16.0*xi+2.0*(12.0-16.0*xi)*eta+(36.0-48.0*xi+2.0*(-36.0+48.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (36.0-48.0*xi)*eta+(-36.0+48.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = -12.0+16.0*xi+2.0*(12.0-16.0*xi)*eta+(36.0-48.0*xi+2.0*(-36.0+48.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = -8.0+24.0*xi-16.0*xi*xi+(24.0-72.0*xi+48.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -12.0+36.0*xi-24.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (36.0-48.0*xi)*eta+(-36.0+48.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -12.0+36.0*xi-24.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = 16.0*eta-16.0*eta*eta+(-48.0*eta+48.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = -4.0+16.0*xi+2.0*(4.0-16.0*xi)*eta+(12.0-48.0*xi+2.0*(-12.0+48.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (12.0-48.0*xi)*eta+(-12.0+48.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = -4.0+16.0*xi+2.0*(4.0-16.0*xi)*eta+(12.0-48.0*xi+2.0*(-12.0+48.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = 8.0*xi-16.0*xi*xi+(-24.0*xi+48.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 12.0*xi-24.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (12.0-48.0*xi)*eta+(-12.0+48.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 12.0*xi-24.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = (-16.0*eta+16.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (4.0-16.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (4.0-16.0*xi)*eta+(-4.0+16.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (4.0-16.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (-8.0*xi+16.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 4.0*xi-8.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (4.0-16.0*xi)*eta+(-4.0+16.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 4.0*xi-8.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = (-16.0*eta+16.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (12.0-16.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (12.0-16.0*xi)*eta+(-12.0+16.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (12.0-16.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (8.0-24.0*xi+16.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -4.0+12.0*xi-8.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (12.0-16.0*xi)*eta+(-12.0+16.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -4.0+12.0*xi-8.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
+return_value[0][0] = (-32.0+96.0*eta-64.0*eta*eta)*zeta+(32.0-96.0*eta+64.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (-48.0+96.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(48.0-96.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = 16.0-32.0*xi+(-48.0+96.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*(-16.0+32.0*xi+(48.0-96.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (-48.0+96.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(48.0-96.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (64.0*xi-64.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -48.0*xi+48.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(48.0*xi-48.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][0] = 16.0-32.0*xi+(-48.0+96.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*(-16.0+32.0*xi+(48.0-96.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -48.0*xi+48.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(48.0*xi-48.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][2] = -32.0*xi+32.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
+return_value[0][0] = (32.0*eta-64.0*eta*eta)*zeta+(-32.0*eta+64.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (-16.0+32.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(16.0-32.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (-16.0+32.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*((16.0-32.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (-16.0+32.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(16.0-32.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (64.0*xi-64.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -16.0*xi+16.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (-16.0+32.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*((16.0-32.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -16.0*xi+16.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(16.0*xi-16.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
+return_value[0][0] = -32.0*eta+32.0*eta*eta+(96.0*eta-96.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
+return_value[0][1] = 16.0-32.0*xi+2.0*(-16.0+32.0*xi)*eta+(-48.0+96.0*xi+2.0*(48.0-96.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (-48.0+96.0*xi)*eta+(48.0-96.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+return_value[1][0] = 16.0-32.0*xi+2.0*(-16.0+32.0*xi)*eta+(-48.0+96.0*xi+2.0*(48.0-96.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = -32.0*xi+32.0*xi*xi+(96.0*xi-96.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -48.0*xi+48.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (-48.0+96.0*xi)*eta+(48.0-96.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -48.0*xi+48.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
+return_value[0][0] = (64.0*eta-64.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (-16.0+64.0*xi+2.0*(16.0-64.0*xi)*eta)*zeta+(16.0-64.0*xi+2.0*(-16.0+64.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (-16.0+64.0*xi)*eta+(16.0-64.0*xi)*eta*eta+2.0*((16.0-64.0*xi)*eta+(-16.0+64.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (-16.0+64.0*xi+2.0*(16.0-64.0*xi)*eta)*zeta+(16.0-64.0*xi+2.0*(-16.0+64.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (32.0*xi-64.0*xi*xi)*zeta+(-32.0*xi+64.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -16.0*xi+32.0*xi*xi+2.0*(16.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-32.0*xi*xi+2.0*(-16.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (-16.0+64.0*xi)*eta+(16.0-64.0*xi)*eta*eta+2.0*((16.0-64.0*xi)*eta+(-16.0+64.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -16.0*xi+32.0*xi*xi+2.0*(16.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-32.0*xi*xi+2.0*(-16.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(16.0*xi-32.0*xi*xi)*eta+2.0*(-16.0*xi+32.0*xi*xi)*eta*eta;
+return_value[0][0] = (32.0*eta-32.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (-16.0+32.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (-16.0+32.0*xi)*eta+(16.0-32.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (-16.0+32.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (32.0*xi-32.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
+return_value[1][2] = -16.0*xi+16.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (-16.0+32.0*xi)*eta+(16.0-32.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+return_value[2][1] = -16.0*xi+16.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
+return_value[0][0] = (64.0*eta-64.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (-48.0+64.0*xi+2.0*(48.0-64.0*xi)*eta)*zeta+(48.0-64.0*xi+2.0*(-48.0+64.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (-48.0+64.0*xi)*eta+(48.0-64.0*xi)*eta*eta+2.0*((48.0-64.0*xi)*eta+(-48.0+64.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (-48.0+64.0*xi+2.0*(48.0-64.0*xi)*eta)*zeta+(48.0-64.0*xi+2.0*(-48.0+64.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (-32.0+96.0*xi-64.0*xi*xi)*zeta+(32.0-96.0*xi+64.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 16.0-48.0*xi+32.0*xi*xi+2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta+2.0*(-16.0+48.0*xi-32.0*xi*xi+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (-48.0+64.0*xi)*eta+(48.0-64.0*xi)*eta*eta+2.0*((48.0-64.0*xi)*eta+(-48.0+64.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 16.0-48.0*xi+32.0*xi*xi+2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta+2.0*(-16.0+48.0*xi-32.0*xi*xi+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta*eta;
+return_value[0][0] = (-128.0*eta+128.0*eta*eta)*zeta+(128.0*eta-128.0*eta*eta)*zeta*zeta;
+return_value[0][1] = (64.0-128.0*xi+2.0*(-64.0+128.0*xi)*eta)*zeta+(-64.0+128.0*xi+2.0*(64.0-128.0*xi)*eta)*zeta*zeta;
+return_value[0][2] = (64.0-128.0*xi)*eta+(-64.0+128.0*xi)*eta*eta+2.0*((-64.0+128.0*xi)*eta+(64.0-128.0*xi)*eta*eta)*zeta;
+return_value[1][0] = (64.0-128.0*xi+2.0*(-64.0+128.0*xi)*eta)*zeta+(-64.0+128.0*xi+2.0*(64.0-128.0*xi)*eta)*zeta*zeta;
+return_value[1][1] = (-128.0*xi+128.0*xi*xi)*zeta+(128.0*xi-128.0*xi*xi)*zeta*zeta;
+return_value[1][2] = 64.0*xi-64.0*xi*xi+2.0*(-64.0*xi+64.0*xi*xi)*eta+2.0*(-64.0*xi+64.0*xi*xi+2.0*(64.0*xi-64.0*xi*xi)*eta)*zeta;
+return_value[2][0] = (64.0-128.0*xi)*eta+(-64.0+128.0*xi)*eta*eta+2.0*((-64.0+128.0*xi)*eta+(64.0-128.0*xi)*eta*eta)*zeta;
+return_value[2][1] = 64.0*xi-64.0*xi*xi+2.0*(-64.0*xi+64.0*xi*xi)*eta+2.0*(-64.0*xi+64.0*xi*xi+2.0*(64.0*xi-64.0*xi*xi)*eta)*zeta;
+return_value[2][2] = 2.0*(-64.0*xi+64.0*xi*xi)*eta+2.0*(64.0*xi-64.0*xi*xi)*eta*eta;
+ break;
+    };
+  return return_value;
+};
+
+
+
+template <>
+void FEQuadraticSub<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
+                                              const Boundary<3> &,
+                                              dFMatrix &local_mass_matrix) const {
+  Assert (local_mass_matrix.n() == total_dofs,
+         ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
+  Assert (local_mass_matrix.m() == total_dofs,
+         ExcWrongFieldDimension(local_mass_matrix.m(),total_dofs));
+
+  AssertThrow (false, ExcComputationNotUseful(3));
+};
+
+
+
+template <>
+void FEQuadraticSub<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
+  Assert (unit_points.size() == total_dofs,
+         ExcWrongFieldDimension (unit_points.size(), total_dofs));
+  
+  unit_points[0] = Point<3>(0, 0, 0);
+  unit_points[1] = Point<3>(1, 0, 0);
+  unit_points[2] = Point<3>(1, 0, 1);
+  unit_points[3] = Point<3>(0, 0, 1);
+  unit_points[4] = Point<3>(0, 1, 0);
+  unit_points[5] = Point<3>(1, 1, 0);
+  unit_points[6] = Point<3>(1, 1, 1);
+  unit_points[7] = Point<3>(0, 1, 1);
+  unit_points[8] = Point<3>(1/2, 0, 0);
+  unit_points[9] = Point<3>(1, 0, 1/2);
+  unit_points[10] = Point<3>(1/2, 0, 1);
+  unit_points[11] = Point<3>(0, 0, 1/2);
+  unit_points[12] = Point<3>(1/2, 1, 0);
+  unit_points[13] = Point<3>(1, 1, 1/2);
+  unit_points[14] = Point<3>(1/2, 1, 1);
+  unit_points[15] = Point<3>(0, 1, 1/2);
+  unit_points[16] = Point<3>(0, 1/2, 0);
+  unit_points[17] = Point<3>(1, 1/2, 0);
+  unit_points[18] = Point<3>(1, 1/2, 1);
+  unit_points[19] = Point<3>(0, 1/2, 1);
+  unit_points[20] = Point<3>(1/2, 0, 1/2);
+  unit_points[21] = Point<3>(1/2, 1, 1/2);
+  unit_points[22] = Point<3>(1/2, 1/2, 0);
+  unit_points[23] = Point<3>(1, 1/2, 1/2);
+  unit_points[24] = Point<3>(1/2, 1/2, 1);
+  unit_points[25] = Point<3>(0, 1/2, 1/2);
+  unit_points[26] = Point<3>(1/2, 1/2, 1/2);
+};
+
+  
+
+template <>
+void FEQuadraticSub<3>::get_support_points (const typename DoFHandler<3>::cell_iterator &cell,
+                                           const Boundary<3>&,
+                                           vector<Point<3> >  &support_points) const {
+  Assert (support_points.size() == total_dofs,
+         ExcWrongFieldDimension (support_points.size(), total_dofs));
+
+  const Point<3> vertices[8] = { cell->vertex(0),
+                                cell->vertex(1),
+                                cell->vertex(2),
+                                cell->vertex(3),
+                                cell->vertex(4),
+                                cell->vertex(5),
+                                cell->vertex(6),
+                                cell->vertex(7)  };
+  
+  support_points[0](0) = vertices[0](0);
+  support_points[0](1) = vertices[0](1);
+  support_points[0](2) = vertices[0](2);
+  support_points[1](0) = vertices[1](0);
+  support_points[1](1) = vertices[1](1);
+  support_points[1](2) = vertices[1](2);
+  support_points[2](0) = vertices[2](0);
+  support_points[2](1) = vertices[2](1);
+  support_points[2](2) = vertices[2](2);
+  support_points[3](0) = vertices[3](0);
+  support_points[3](1) = vertices[3](1);
+  support_points[3](2) = vertices[3](2);
+  support_points[4](0) = vertices[4](0);
+  support_points[4](1) = vertices[4](1);
+  support_points[4](2) = vertices[4](2);
+  support_points[5](0) = vertices[5](0);
+  support_points[5](1) = vertices[5](1);
+  support_points[5](2) = vertices[5](2);
+  support_points[6](0) = vertices[6](0);
+  support_points[6](1) = vertices[6](1);
+  support_points[6](2) = vertices[6](2);
+  support_points[7](0) = vertices[7](0);
+  support_points[7](1) = vertices[7](1);
+  support_points[7](2) = vertices[7](2);
+  support_points[8](0) = vertices[0](0)/2.0+vertices[1](0)/2.0;
+  support_points[8](1) = vertices[0](1)/2.0+vertices[1](1)/2.0;
+  support_points[8](2) = vertices[0](2)/2.0+vertices[1](2)/2.0;
+  support_points[9](0) = vertices[1](0)/2.0+vertices[2](0)/2.0;
+  support_points[9](1) = vertices[1](1)/2.0+vertices[2](1)/2.0;
+  support_points[9](2) = vertices[1](2)/2.0+vertices[2](2)/2.0;
+  support_points[10](0) = vertices[2](0)/2.0+vertices[3](0)/2.0;
+  support_points[10](1) = vertices[2](1)/2.0+vertices[3](1)/2.0;
+  support_points[10](2) = vertices[2](2)/2.0+vertices[3](2)/2.0;
+  support_points[11](0) = vertices[0](0)/2.0+vertices[3](0)/2.0;
+  support_points[11](1) = vertices[0](1)/2.0+vertices[3](1)/2.0;
+  support_points[11](2) = vertices[0](2)/2.0+vertices[3](2)/2.0;
+  support_points[12](0) = vertices[4](0)/2.0+vertices[5](0)/2.0;
+  support_points[12](1) = vertices[4](1)/2.0+vertices[5](1)/2.0;
+  support_points[12](2) = vertices[4](2)/2.0+vertices[5](2)/2.0;
+  support_points[13](0) = vertices[5](0)/2.0+vertices[6](0)/2.0;
+  support_points[13](1) = vertices[5](1)/2.0+vertices[6](1)/2.0;
+  support_points[13](2) = vertices[5](2)/2.0+vertices[6](2)/2.0;
+  support_points[14](0) = vertices[6](0)/2.0+vertices[7](0)/2.0;
+  support_points[14](1) = vertices[6](1)/2.0+vertices[7](1)/2.0;
+  support_points[14](2) = vertices[6](2)/2.0+vertices[7](2)/2.0;
+  support_points[15](0) = vertices[4](0)/2.0+vertices[7](0)/2.0;
+  support_points[15](1) = vertices[4](1)/2.0+vertices[7](1)/2.0;
+  support_points[15](2) = vertices[4](2)/2.0+vertices[7](2)/2.0;
+  support_points[16](0) = vertices[0](0)/2.0+vertices[4](0)/2.0;
+  support_points[16](1) = vertices[0](1)/2.0+vertices[4](1)/2.0;
+  support_points[16](2) = vertices[0](2)/2.0+vertices[4](2)/2.0;
+  support_points[17](0) = vertices[1](0)/2.0+vertices[5](0)/2.0;
+  support_points[17](1) = vertices[1](1)/2.0+vertices[5](1)/2.0;
+  support_points[17](2) = vertices[1](2)/2.0+vertices[5](2)/2.0;
+  support_points[18](0) = vertices[2](0)/2.0+vertices[6](0)/2.0;
+  support_points[18](1) = vertices[2](1)/2.0+vertices[6](1)/2.0;
+  support_points[18](2) = vertices[2](2)/2.0+vertices[6](2)/2.0;
+  support_points[19](0) = vertices[3](0)/2.0+vertices[7](0)/2.0;
+  support_points[19](1) = vertices[3](1)/2.0+vertices[7](1)/2.0;
+  support_points[19](2) = vertices[3](2)/2.0+vertices[7](2)/2.0;
+  support_points[20](0) = vertices[0](0)/4.0+vertices[1](0)/4.0+vertices[2](0)/4.0+vertices[3](0)/4.0;
+  support_points[20](1) = vertices[0](1)/4.0+vertices[1](1)/4.0+vertices[2](1)/4.0+vertices[3](1)/4.0;
+  support_points[20](2) = vertices[0](2)/4.0+vertices[1](2)/4.0+vertices[2](2)/4.0+vertices[3](2)/4.0;
+  support_points[21](0) = vertices[4](0)/4.0+vertices[5](0)/4.0+vertices[6](0)/4.0+vertices[7](0)/4.0;
+  support_points[21](1) = vertices[4](1)/4.0+vertices[5](1)/4.0+vertices[6](1)/4.0+vertices[7](1)/4.0;
+  support_points[21](2) = vertices[4](2)/4.0+vertices[5](2)/4.0+vertices[6](2)/4.0+vertices[7](2)/4.0;
+  support_points[22](0) = vertices[0](0)/4.0+vertices[1](0)/4.0+vertices[4](0)/4.0+vertices[5](0)/4.0;
+  support_points[22](1) = vertices[0](1)/4.0+vertices[1](1)/4.0+vertices[4](1)/4.0+vertices[5](1)/4.0;
+  support_points[22](2) = vertices[0](2)/4.0+vertices[1](2)/4.0+vertices[4](2)/4.0+vertices[5](2)/4.0;
+  support_points[23](0) = vertices[1](0)/4.0+vertices[2](0)/4.0+vertices[5](0)/4.0+vertices[6](0)/4.0;
+  support_points[23](1) = vertices[1](1)/4.0+vertices[2](1)/4.0+vertices[5](1)/4.0+vertices[6](1)/4.0;
+  support_points[23](2) = vertices[1](2)/4.0+vertices[2](2)/4.0+vertices[5](2)/4.0+vertices[6](2)/4.0;
+  support_points[24](0) = vertices[2](0)/4.0+vertices[3](0)/4.0+vertices[6](0)/4.0+vertices[7](0)/4.0;
+  support_points[24](1) = vertices[2](1)/4.0+vertices[3](1)/4.0+vertices[6](1)/4.0+vertices[7](1)/4.0;
+  support_points[24](2) = vertices[2](2)/4.0+vertices[3](2)/4.0+vertices[6](2)/4.0+vertices[7](2)/4.0;
+  support_points[25](0) = vertices[0](0)/4.0+vertices[3](0)/4.0+vertices[4](0)/4.0+vertices[7](0)/4.0;
+  support_points[25](1) = vertices[0](1)/4.0+vertices[3](1)/4.0+vertices[4](1)/4.0+vertices[7](1)/4.0;
+  support_points[25](2) = vertices[0](2)/4.0+vertices[3](2)/4.0+vertices[4](2)/4.0+vertices[7](2)/4.0;
+  support_points[26](0) = vertices[0](0)/8.0+vertices[1](0)/8.0+vertices[2](0)/8.0+vertices[3](0)/8.0+vertices[4](0)/8.0+vertices[5](0)/8.0+vertices[6](0)/8.0+vertices[7](0)/8.0;
+  support_points[26](1) = vertices[0](1)/8.0+vertices[1](1)/8.0+vertices[2](1)/8.0+vertices[3](1)/8.0+vertices[4](1)/8.0+vertices[5](1)/8.0+vertices[6](1)/8.0+vertices[7](1)/8.0;
+  support_points[26](2) = vertices[0](2)/8.0+vertices[1](2)/8.0+vertices[2](2)/8.0+vertices[3](2)/8.0+vertices[4](2)/8.0+vertices[5](2)/8.0+vertices[6](2)/8.0+vertices[7](2)/8.0;
+};
+
+
+
+template <>
+void FEQuadraticSub<3>::get_face_support_points (const typename DoFHandler<3>::face_iterator &face,
+                                                const Boundary<3>  &,
+                                                vector<Point<3> >  &support_points) const {
+  Assert (support_points.size() == dofs_per_face,
+         ExcWrongFieldDimension (support_points.size(), dofs_per_face));
+
+  for (unsigned int vertex=0; vertex<4; ++vertex)
+    support_points[vertex] = face->vertex(vertex);
+  for (unsigned int line=0; line<4; ++line)
+    support_points[4+line] = (support_points[line] + support_points[(line+4)%4]) / 2;
+  support_points[8] = (support_points[0] +
+                      support_points[1] +
+                      support_points[2] +
+                      support_points[3]) / 4;
+};
+
 #endif
 
 
index a5b47dbce5791c139e5b2a1e2a7e54b4524f8b25..0d0acd43979a11f24ad08a9d59a74276f532f199 100644 (file)
@@ -8,7 +8,7 @@
 #include <grid/dof_accessor.h>
 #include <grid/tria_boundary.h>
 
-
+#include <cmath>
 
 
 
 template <>
 FELinearMapping<1>::FELinearMapping (const unsigned int dofs_per_vertex,
                                     const unsigned int dofs_per_line,
-                                    const unsigned int dofs_per_quad) :
+                                    const unsigned int dofs_per_quad,
+                                    const unsigned int dofs_per_hex,
+                                    const unsigned int n_components) :
                FiniteElement<1> (FiniteElementData<1> (dofs_per_vertex,
                                                        dofs_per_line,
                                                        GeometryInfo<1>::vertices_per_cell,
-                                                       1))
+                                                       n_components))
 {
   Assert (dofs_per_quad==0, ExcInvalidData());
+  Assert (dofs_per_hex==0,  ExcInvalidData());
 };
 
 
@@ -143,13 +146,17 @@ void FELinearMapping<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &cel
 template <>
 FELinearMapping<2>::FELinearMapping (const unsigned int dofs_per_vertex,
                                     const unsigned int dofs_per_line,
-                                    const unsigned int dofs_per_quad) :
+                                    const unsigned int dofs_per_quad,
+                                    const unsigned int dofs_per_hex,
+                                    const unsigned int n_components) :
                FiniteElement<2> (FiniteElementData<2> (dofs_per_vertex,
                                                        dofs_per_line,
                                                        dofs_per_quad,
                                                        GeometryInfo<2>::vertices_per_cell,
-                                                       1))
-{};
+                                                       n_components))
+{
+  Assert (dofs_per_hex == 0, ExcInvalidData());
+};
 
 
 
@@ -308,6 +315,245 @@ void FELinearMapping<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator
 
 
 
+#if deal_II_dimension == 3
+
+template <>
+FELinearMapping<3>::FELinearMapping (const unsigned int dofs_per_vertex,
+                                    const unsigned int dofs_per_line,
+                                    const unsigned int dofs_per_quad,
+                                    const unsigned int dofs_per_hex,
+                                    const unsigned int n_components) :
+               FiniteElement<3> (FiniteElementData<3> (dofs_per_vertex,
+                                                       dofs_per_line,
+                                                       dofs_per_quad,
+                                                       dofs_per_hex,
+                                                       GeometryInfo<3>::vertices_per_cell,
+                                                       n_components))
+{};
+
+
+
+template <>
+inline
+double
+FELinearMapping<3>::shape_value_transform (const unsigned int i,
+                                          const Point<3>& p) const
+{
+  Assert((i<8), ExcInvalidIndex(i));
+  switch (i)
+    {
+      case 0: return 1.0-p(0)+(-1.0+p(0))*p(1)+(-1.0+p(0)+(1.0-p(0))*p(1))*p(2);
+      case 1: return p(0)-p(0)*p(1)+(-p(0)+p(0)*p(1))*p(2);
+      case 2: return (p(0)-p(0)*p(1))*p(2);
+      case 3: return (1.0-p(0)+(-1.0+p(0))*p(1))*p(2);
+      case 4: return (1.0-p(0))*p(1)+(-1.0+p(0))*p(1)*p(2);
+      case 5: return p(0)*p(1)-p(0)*p(1)*p(2);
+      case 6: return p(0)*p(1)*p(2);
+      case 7: return (1.0-p(0))*p(1)*p(2);
+    }
+  return 0.;
+};
+
+
+
+template <>
+inline
+Tensor<1,3>
+FELinearMapping<3>::shape_grad_transform (const unsigned int i,
+                                         const Point<3>& p) const
+{
+  Assert((i<8), ExcInvalidIndex(i));
+  switch (i)
+    {
+      case 0: return Point<3>(-1.0+p(1)+(1.0-p(1))*p(2),
+                             -1.0+p(0)+(1.0-p(0))*p(2),
+                             -1.0+p(0)+(1.0-p(0))*p(1));
+      case 1: return Point<3>(1.0-p(1)+(-1.0+p(1))*p(2),
+                             -p(0)+p(0)*p(2),
+                             -p(0)+p(0)*p(1));
+      case 2: return Point<3>((1.0-p(1))*p(2),
+                             -p(0)*p(2),
+                             p(0)-p(0)*p(1));
+      case 3: return Point<3>((-1.0+p(1))*p(2),
+                             (-1.0+p(0))*p(2),
+                             1.0-p(0)+(-1.0+p(0))*p(1));
+      case 4: return Point<3>(-p(1)+p(1)*p(2),
+                             1.0-p(0)+(-1.0+p(0))*p(2),
+                             (-1.0+p(0))*p(1));
+      case 5: return Point<3>(p(1)-p(1)*p(2),
+                             p(0)-p(0)*p(2),
+                             -p(0)*p(1));
+      case 6: return Point<3>(p(1)*p(2),
+                             p(0)*p(2),
+                             p(0)*p(1));
+      case 7: return Point<3>(-p(1)*p(2),
+                             (1.0-p(0))*p(2),
+                             (1.0-p(0))*p(1));
+    }
+  return Point<3> ();
+};
+
+
+
+template <>
+void FELinearMapping<3>::get_face_jacobians (const DoFHandler<3>::face_iterator &face,
+                                            const Boundary<3>         &,
+                                            const vector<Point<2> > &unit_points,
+                                            vector<double> &face_jacobians) const {
+  Assert (unit_points.size() == face_jacobians.size(),
+         ExcWrongFieldDimension (unit_points.size(), face_jacobians.size()));
+
+                                  // the computation of the face jacobians is
+                                  // along the following lines: let x_i be
+                                  // the four vertices of a face, then the
+                                  // unit point (xi,eta) is mapped to the
+                                  // point vec x(xi,eta)=\sum x_i phi_i(xi,eta),
+                                  // with phi_i being the shape functions
+                                  // of this face
+                                  //
+                                  // now, while d(xi) d(eta) is the area
+                                  // element on the unit face,
+                                  // abs(dx dy) is the respective element
+                                  // of the real face. to compute it, we
+                                  // compute the image of the elements d(xi)
+                                  // and d(eta):
+                                  // (\vec x(xi+dxi,eta) - \vec x(xi,eta) )
+                                  // (\vec x(xi,eta+deta) - \vec x(xi,eta) )
+                                  // the area then is the norm of the
+                                  // cross product of these two vectors
+                                  // and the determinant is the area
+                                  // divided by d(xi)d(eta)
+                                  //
+                                  // written down, we remark that the
+                                  // determinant we are looking for is
+                                  // the cross product of the following
+                                  // two vectors:
+                                  // d/d(xi)  vec x(xi,eta)
+                                  // d/d(eta) vec x(xi,eta)
+                                  // we then arrive at:
+                                  //
+                                  // detJ =
+                                  // || \sum_l \sum_k \phi_{l,xi} \phi_{k,eta}
+                                  //        x_l \times x_k ||
+                                  //
+                                  // a maple script doing this computation is
+                                  // in the <scripts> directory
+  const Point<3> vertices[4] = { face->vertex(0),
+                                face->vertex(1),
+                                face->vertex(2),
+                                face->vertex(3)   };
+
+  for (unsigned int point=0; point<unit_points.size(); ++point)
+    {
+      const double xi  = unit_points[point](0),
+                  eta = unit_points[point](1);
+
+      const double t1 = 1.0-eta;
+      const double t6 = -vertices[0](1)*t1+vertices[1](1)*t1+vertices[2](1)*eta-vertices[3](1)*eta;
+      const double t7 = 1.0-xi;
+      const double t12 = -vertices[0](2)*t7-vertices[1](2)*xi+vertices[2](2)*xi+vertices[3](2)*t7;
+      const double t18 = -vertices[0](2)*t1+vertices[1](2)*t1+vertices[2](2)*eta-vertices[3](2)*eta;
+      const double t23 = -vertices[0](1)*t7-vertices[1](1)*xi+vertices[2](1)*xi+vertices[3](1)*t7;
+      const double t26 = fabs(t6*t12-t18*t23);
+      const double t27 = t26*t26;
+      const double t32 = -vertices[0](0)*t7-vertices[1](0)*xi+vertices[2](0)*xi+vertices[3](0)*t7;
+      const double t38 = -vertices[0](0)*t1+vertices[1](0)*t1+vertices[2](0)*eta-vertices[3](0)*eta;
+      const double t41 = fabs(t18*t32-t38*t12);
+      const double t42 = t41*t41;
+      const double t46 = fabs(t38*t23-t6*t32);
+      const double t47 = t46*t46;
+      face_jacobians[point] = sqrt(t27+t42+t47);
+    };
+};
+
+
+
+template <>
+void FELinearMapping<3>::get_subface_jacobians (const DoFHandler<3>::face_iterator &/*face*/,
+                                               const unsigned int           ,
+                                               const vector<Point<2> > &unit_points,
+                                               vector<double> &face_jacobians) const {
+  Assert (false,
+         ExcWrongFieldDimension (unit_points.size(), face_jacobians.size()));
+};
+
+
+
+template <>
+void FELinearMapping<3>::get_normal_vectors (const DoFHandler<3>::cell_iterator &cell,
+                                            const unsigned int       face_no,
+                                            const Boundary<3>       &,
+                                            const vector<Point<2> > &unit_points,
+                                            vector<Point<3> > &normal_vectors) const {
+  Assert (unit_points.size() == normal_vectors.size(),
+         ExcWrongFieldDimension (unit_points.size(), normal_vectors.size()));
+  
+                                  // taken from the same script as is
+                                  // the computation of the jacobian
+                                  // determinant above
+
+  const Point<3> vertices[4] = { cell->face(face_no)->vertex(0),
+                                cell->face(face_no)->vertex(1),
+                                cell->face(face_no)->vertex(2),
+                                cell->face(face_no)->vertex(3)   };
+
+  for (unsigned int point=0; point<unit_points.size(); ++point)
+    {
+      const double xi  = unit_points[point](0),
+                  eta = unit_points[point](1);
+      
+      const double t1 = 1.0-eta;
+      const double t6 = -vertices[0](1)*t1+vertices[1](1)*t1+vertices[2](1)*eta-vertices[3](1)*eta;
+      const double t7 = 1.0-xi;
+      const double t12 = -vertices[0](2)*t7-vertices[1](2)*xi+vertices[2](2)*xi+vertices[3](2)*t7;
+      const double t18 = -vertices[0](2)*t1+vertices[1](2)*t1+vertices[2](2)*eta-vertices[3](2)*eta;
+      const double t23 = -vertices[0](1)*t7-vertices[1](1)*xi+vertices[2](1)*xi+vertices[3](1)*t7;
+      const double t25 = t6*t12-t18*t23;
+      const double t26 = fabs(t25);
+      const double t27 = t26*t26;
+      const double t32 = -vertices[0](0)*t7-vertices[1](0)*xi+vertices[2](0)*xi+vertices[3](0)*t7;
+      const double t38 = -vertices[0](0)*t1+vertices[1](0)*t1+vertices[2](0)*eta-vertices[3](0)*eta;
+      const double t40 = t18*t32-t38*t12;
+      const double t41 = fabs(t40);
+      const double t42 = t41*t41;
+      const double t45 = t38*t23-t6*t32;
+      const double t46 = fabs(t45);
+      const double t47 = t46*t46;
+      const double t49 = sqrt(t27+t42+t47);
+      const double t50 = 1/t49;
+      
+      normal_vectors[point](0) = t25*t50;
+      normal_vectors[point](1) = t40*t50;
+      normal_vectors[point](2) = t45*t50;
+
+      if ((face_no == 1) ||
+         (face_no == 2) ||
+         (face_no == 5))
+       normal_vectors[point] *= -1;
+    };  
+};
+
+
+
+template <>
+void FELinearMapping<3>::get_normal_vectors (const DoFHandler<3>::cell_iterator &/*cell*/,
+                                            const unsigned int       /*face_no*/,
+                                            const unsigned int,
+                                            const vector<Point<2> > &unit_points,
+                                            vector<Point<3> > &normal_vectors) const {
+                                  // more or less copied from the linear
+                                  // finite element
+                                  // note, that in 2D the normal vectors to the
+                                  // subface have the same direction as that
+                                  // for the face
+  Assert (false,
+         ExcWrongFieldDimension (unit_points.size(), normal_vectors.size()));
+};
+
+#endif
+
+
+
 template <int dim>
 void FELinearMapping<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
                                           const vector<Point<dim> >            &unit_points,
@@ -471,147 +717,10 @@ void FELinearMapping<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator
 */
 
   if (compute_jacobians)
-    switch (dim)
-      {
-       case 1:
-             for (unsigned int point=0; point<n_points; ++point)
-               jacobians[point][0][0] = 1./(vertices[1](0)-vertices[0](0));
-             break;
-               
-       case 2:
-       {
-         for (unsigned int point=0; point<n_points; ++point)
-           {       
-             const double xi = unit_points[point](0);
-             const double eta= unit_points[point](1);
-       
-             const double t6 = vertices[0](0)*vertices[3](1);
-             const double t8 = vertices[2](0)*xi;
-             const double t10 = vertices[1](0)*eta;
-             const double t12 = vertices[3](0)*vertices[1](1);
-             const double t16 = vertices[3](0)*xi;
-             const double t20 = vertices[0](0)*vertices[1](1);
-             const double t22 = vertices[0](0)*vertices[2](1);
-             const double t24 = t6*xi-t8*vertices[1](1)-t10*vertices[3](1)+
-                                t12*eta-vertices[3](0)*vertices[2](1)*eta-
-                                t16*vertices[0](1)+t16*vertices[1](1)-t12+
-                                vertices[3](0)*vertices[0](1)-t20*eta+t22*eta;
-             const double t28 = vertices[1](0)*vertices[3](1);
-             const double t31 = vertices[2](0)*eta;
-             const double t36 = t8*vertices[0](1)+vertices[1](0)*vertices[2](1)*xi-
-                                t28*xi+t10*vertices[0](1)-t31*vertices[0](1)+
-                                t31*vertices[3](1)+t20-t6-vertices[1](0)*
-                                vertices[0](1)+t28-t22*xi;
-             const double t38 = 1/(t24+t36);
-
-             jacobians[point][0][0] = (-vertices[0](1)+vertices[0](1)*xi-
-                                       vertices[1](1)*xi+vertices[2](1)*xi+
-                                       vertices[3](1)-vertices[3](1)*xi)*t38;
-             jacobians[point][0][1] = -(-vertices[0](0)+vertices[0](0)*xi-
-                                        vertices[1](0)*xi+t8+vertices[3](0)-t16)*t38;
-             jacobians[point][1][0] = -(-vertices[0](1)+vertices[0](1)*eta+
-                                        vertices[1](1)-vertices[1](1)*eta+
-                                        vertices[2](1)*eta-vertices[3](1)*eta)*t38;
-             jacobians[point][1][1] = (-vertices[0](0)+vertices[0](0)*eta+
-                                       vertices[1](0)-t10+t31-vertices[3](0)*eta)*t38;
-           };
-         
-         break;
-       };
-
-       default:
-                                              // not implemented at present
-             Assert (false, ExcNotImplemented());
-      };
-
+    compute_jacobian_matrices (cell, unit_points, jacobians);
   
   if (compute_jacobians_grad)
-    switch (dim) 
-      {
-       case 1:
-       {
-                                          // derivative of the
-                                          // jacobian is always zero
-                                          // for a linear mapping in 1d
-         for (unsigned int point=0; point<n_points; ++point)
-           jacobians_grad[point][0][0][0] = 0;
-         break;
-       };
-
-       case 2:
-       {
-         for (unsigned int point=0; point<n_points; ++point)
-           {
-             const double xi = unit_points[point](0);
-             const double eta= unit_points[point](1);
-       
-             const double t2 = vertices[1](0)*eta;
-             const double t4 = vertices[3](0)*vertices[2](1);
-             const double t6 = vertices[0](0)*vertices[2](1);
-             const double t8 = vertices[0](0)*vertices[3](1);
-             const double t10 = vertices[3](0)*xi;
-             const double t13 = vertices[2](0)*xi;
-             const double t16 = vertices[3](0)*vertices[1](1);
-             const double t18 = vertices[0](0)*vertices[1](1);
-             const double t19 = vertices[3](0)*vertices[0](1);
-             const double t20 = -t2*vertices[3](1)-t4*eta-t6*xi+t8*xi-
-                                t10*vertices[0](1)+t10*vertices[1](1)+
-                                t13*vertices[0](1)-t13*vertices[1](1)+t16
-                                *eta+t18+t19;
-             const double t23 = vertices[1](0)*vertices[3](1);
-             const double t26 = vertices[2](0)*eta;
-             const double t29 = vertices[1](0)*vertices[0](1);
-             const double t30 = vertices[1](0)*vertices[2](1);
-             const double t32 = -t16-t18*eta+t6*eta-t23*xi+t2*vertices[0](1)-
-                                t26*vertices[0](1)+t26*vertices[3](1)-
-                                t8-t29+t23+t30
-                                *xi;
-             const double t33 = t20+t32;
-             const double t34 = 1/t33;
-             const double t35 = (vertices[0](1)-vertices[1](1)+
-                                 vertices[2](1)-vertices[3](1))*t34;
-             const double t41 = t33*t33;
-             const double t42 = 1/t41;
-             const double t43 = (-vertices[0](1)+vertices[0](1)*xi-
-                                 vertices[1](1)*xi+vertices[2](1)*xi+
-                                 vertices[3](1)-vertices[3](1)*xi)*t42;
-             const double t44 = vertices[2](0)*vertices[0](1);
-             const double t46 = -t6+t8-t19+t16+t44-
-                                vertices[2](0)*vertices[1](1)-
-                                t23+t30;
-             const double t50 = (vertices[0](0)-vertices[1](0)+
-                                 vertices[2](0)-vertices[3](0))*t34;
-             const double t54 = (-vertices[0](0)+vertices[0](0)*xi-
-                                 vertices[1](0)*xi+t13+
-                                 vertices[3](0)-t10)*t42;
-             const double t62 = (-vertices[0](1)+vertices[0](1)*eta+
-                                 vertices[1](1)-vertices[1](1)*eta+
-                                 vertices[2](1)*eta-
-                                 vertices[3](1)*eta)*t42;
-             const double t67 = (-vertices[0](0)+vertices[0](0)*eta+
-                                 vertices[1](0)-t2+t26-vertices[3](0)*eta)*t42;
-             const double t70 = -t23-t4+t16-t18+t6+t29-t44+
-                                vertices[2](0)*vertices[3](1);
-             jacobians_grad[point][0][0][0] = t35-t43*t46;
-             jacobians_grad[point][0][0][1] = -t50+t54*t46;
-             jacobians_grad[point][0][1][0] = t62*t46;
-             jacobians_grad[point][0][1][1] = -t67*t46;
-             jacobians_grad[point][1][0][0] = -t43*t70;
-             jacobians_grad[point][1][0][1] = t54*t70;
-             jacobians_grad[point][1][1][0] = -t35+t62*t70;
-             jacobians_grad[point][1][1][1] = t50-t67*t70;
-           };
-         break;
-         
-       };
-       
-       default:
-                                              // not implemented at present
-             Assert (false, ExcNotImplemented());
-      };
-       
-             
-  
+    compute_jacobian_gradients (cell, unit_points, jacobians_grad);
     
   if (compute_support_points)
     get_support_points (cell, boundary, support_points);
diff --git a/deal.II/deal.II/source/fe/fe_linear_mapping.jacobians.cc b/deal.II/deal.II/source/fe/fe_linear_mapping.jacobians.cc
new file mode 100644 (file)
index 0000000..694998b
--- /dev/null
@@ -0,0 +1,5832 @@
+/* $Id$ */
+/* Copyright W. Bangerth, University of Heidelberg, 1998 */
+
+
+#include <fe/fe_linear_mapping.h>
+#include <grid/tria_iterator.h>
+#include <grid/dof_accessor.h>
+
+#include <cmath>
+
+
+
+/**
+ * This file has been singled out from fe_linear_mapping.cc because the computation
+ * of the 3d matrices is so extremely large that it can't be done with
+ * optimization switched on. On the other hand, this also is not necessary,
+ * because Maple outputs fairly good optimized code already. Singling out this file
+ * allows to compile this file with less optimization without affecting the other
+ * files.
+ */
+
+
+
+#if deal_II_dimension == 1
+
+template <>
+void FELinearMapping<1>::compute_jacobian_matrices (const DoFHandler<1>::cell_iterator &cell,
+                                                   const vector<Point<1> > &unit_points,
+                                                   vector<Tensor<2,1> >    &jacobians) 
+{
+  Assert (unit_points.size() == jacobians.size(),
+         ExcWrongFieldDimension(jacobians.size(), unit_points.size()));
+
+  const double h = (cell->vertex(1)(0)-cell->vertex(0)(0));
+  
+  for (unsigned int point=0; point<unit_points.size(); ++point)
+    jacobians[point][0][0] = 1./h;
+};
+
+
+
+template <>
+void FELinearMapping<1>::compute_jacobian_gradients (const DoFHandler<1>::cell_iterator &cell,
+                                                    const vector<Point<1> > &unit_points,
+                                                    vector<Tensor<3,1> >    &jacobians_grad) 
+{
+  Assert (unit_points.size() == jacobians_grad.size(),
+         ExcWrongFieldDimension(jacobians_grad.size(), unit_points.size()));
+
+                                  // derivative of the
+                                  // jacobian is always zero
+                                  // for a linear mapping in 1d
+  for (unsigned int point=0; point<unit_points.size(); ++point)
+    jacobians_grad[point][0][0][0] = 0;
+};
+
+
+#endif
+
+
+
+#if deal_II_dimension == 2
+
+template <>
+void FELinearMapping<2>::compute_jacobian_matrices (const DoFHandler<2>::cell_iterator &cell,
+                                                   const vector<Point<2> > &unit_points,
+                                                   vector<Tensor<2,2> >    &jacobians) 
+{
+  const unsigned int dim = 2;
+  
+  Assert (unit_points.size() == jacobians.size(),
+         ExcWrongFieldDimension(jacobians.size(), unit_points.size()));
+  
+  Point<dim> vertices[GeometryInfo<dim>::vertices_per_cell];
+  for (unsigned int l=0; l<GeometryInfo<dim>::vertices_per_cell; ++l)
+    vertices[l] = cell->vertex(l);
+
+  for (unsigned int point=0; point<unit_points.size(); ++point)
+    {      
+      const double xi = unit_points[point](0);
+      const double eta= unit_points[point](1);
+       
+      const double t6 = vertices[0](0)*vertices[3](1);
+      const double t8 = vertices[2](0)*xi;
+      const double t10 = vertices[1](0)*eta;
+      const double t12 = vertices[3](0)*vertices[1](1);
+      const double t16 = vertices[3](0)*xi;
+      const double t20 = vertices[0](0)*vertices[1](1);
+      const double t22 = vertices[0](0)*vertices[2](1);
+      const double t24 = t6*xi-t8*vertices[1](1)-t10*vertices[3](1)+
+                        t12*eta-vertices[3](0)*vertices[2](1)*eta-
+                        t16*vertices[0](1)+t16*vertices[1](1)-t12+
+                        vertices[3](0)*vertices[0](1)-t20*eta+t22*eta;
+      const double t28 = vertices[1](0)*vertices[3](1);
+      const double t31 = vertices[2](0)*eta;
+      const double t36 = t8*vertices[0](1)+vertices[1](0)*vertices[2](1)*xi-
+                        t28*xi+t10*vertices[0](1)-t31*vertices[0](1)+
+                        t31*vertices[3](1)+t20-t6-vertices[1](0)*
+                        vertices[0](1)+t28-t22*xi;
+      const double t38 = 1/(t24+t36);
+
+      jacobians[point][0][0] = (-vertices[0](1)+vertices[0](1)*xi-
+                               vertices[1](1)*xi+vertices[2](1)*xi+
+                               vertices[3](1)-vertices[3](1)*xi)*t38;
+      jacobians[point][0][1] = -(-vertices[0](0)+vertices[0](0)*xi-
+                                vertices[1](0)*xi+t8+vertices[3](0)-t16)*t38;
+      jacobians[point][1][0] = -(-vertices[0](1)+vertices[0](1)*eta+
+                                vertices[1](1)-vertices[1](1)*eta+
+                                vertices[2](1)*eta-vertices[3](1)*eta)*t38;
+      jacobians[point][1][1] = (-vertices[0](0)+vertices[0](0)*eta+
+                               vertices[1](0)-t10+t31-vertices[3](0)*eta)*t38;
+    };
+};
+
+
+
+template <>
+void FELinearMapping<2>::compute_jacobian_gradients (const DoFHandler<2>::cell_iterator &cell,
+                                                    const vector<Point<2> > &unit_points,
+                                                    vector<Tensor<3,2> >    &jacobians_grad) 
+{
+  Assert (unit_points.size() == jacobians_grad.size(),
+         ExcWrongFieldDimension(jacobians_grad.size(), unit_points.size()));
+
+  const unsigned int dim = 2;
+  
+  Point<dim> vertices[GeometryInfo<dim>::vertices_per_cell];
+  for (unsigned int l=0; l<GeometryInfo<dim>::vertices_per_cell; ++l)
+    vertices[l] = cell->vertex(l);
+
+  for (unsigned int point=0; point<unit_points.size(); ++point)
+    {
+      const double xi = unit_points[point](0);
+      const double eta= unit_points[point](1);
+       
+      const double t2 = vertices[1](0)*eta;
+      const double t4 = vertices[3](0)*vertices[2](1);
+      const double t6 = vertices[0](0)*vertices[2](1);
+      const double t8 = vertices[0](0)*vertices[3](1);
+      const double t10 = vertices[3](0)*xi;
+      const double t13 = vertices[2](0)*xi;
+      const double t16 = vertices[3](0)*vertices[1](1);
+      const double t18 = vertices[0](0)*vertices[1](1);
+      const double t19 = vertices[3](0)*vertices[0](1);
+      const double t20 = -t2*vertices[3](1)-t4*eta-t6*xi+t8*xi-
+                        t10*vertices[0](1)+t10*vertices[1](1)+
+                        t13*vertices[0](1)-t13*vertices[1](1)+t16
+                        *eta+t18+t19;
+      const double t23 = vertices[1](0)*vertices[3](1);
+      const double t26 = vertices[2](0)*eta;
+      const double t29 = vertices[1](0)*vertices[0](1);
+      const double t30 = vertices[1](0)*vertices[2](1);
+      const double t32 = -t16-t18*eta+t6*eta-t23*xi+t2*vertices[0](1)-
+                        t26*vertices[0](1)+t26*vertices[3](1)-
+                        t8-t29+t23+t30
+                        *xi;
+      const double t33 = t20+t32;
+      const double t34 = 1/t33;
+      const double t35 = (vertices[0](1)-vertices[1](1)+
+                         vertices[2](1)-vertices[3](1))*t34;
+      const double t41 = t33*t33;
+      const double t42 = 1/t41;
+      const double t43 = (-vertices[0](1)+vertices[0](1)*xi-
+                         vertices[1](1)*xi+vertices[2](1)*xi+
+                         vertices[3](1)-vertices[3](1)*xi)*t42;
+      const double t44 = vertices[2](0)*vertices[0](1);
+      const double t46 = -t6+t8-t19+t16+t44-
+                        vertices[2](0)*vertices[1](1)-
+                        t23+t30;
+      const double t50 = (vertices[0](0)-vertices[1](0)+
+                         vertices[2](0)-vertices[3](0))*t34;
+      const double t54 = (-vertices[0](0)+vertices[0](0)*xi-
+                         vertices[1](0)*xi+t13+
+                         vertices[3](0)-t10)*t42;
+      const double t62 = (-vertices[0](1)+vertices[0](1)*eta+
+                         vertices[1](1)-vertices[1](1)*eta+
+                         vertices[2](1)*eta-
+                         vertices[3](1)*eta)*t42;
+      const double t67 = (-vertices[0](0)+vertices[0](0)*eta+
+                         vertices[1](0)-t2+t26-vertices[3](0)*eta)*t42;
+      const double t70 = -t23-t4+t16-t18+t6+t29-t44+
+                        vertices[2](0)*vertices[3](1);
+      jacobians_grad[point][0][0][0] = t35-t43*t46;
+      jacobians_grad[point][0][0][1] = -t50+t54*t46;
+      jacobians_grad[point][0][1][0] = t62*t46;
+      jacobians_grad[point][0][1][1] = -t67*t46;
+      jacobians_grad[point][1][0][0] = -t43*t70;
+      jacobians_grad[point][1][0][1] = t54*t70;
+      jacobians_grad[point][1][1][0] = -t35+t62*t70;
+      jacobians_grad[point][1][1][1] = t50-t67*t70;
+    };
+};
+
+
+#endif
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+void FELinearMapping<3>::compute_jacobian_matrices (const DoFHandler<3>::cell_iterator &cell,
+                                                   const vector<Point<3> > &unit_points,
+                                                   vector<Tensor<2,3> >    &jacobians) 
+{
+  const unsigned int dim = 3;
+  
+  Assert (unit_points.size() == jacobians.size(),
+         ExcWrongFieldDimension(jacobians.size(), unit_points.size()));
+
+  Point<dim> vertices[GeometryInfo<dim>::vertices_per_cell];
+  for (unsigned int l=0; l<GeometryInfo<dim>::vertices_per_cell; ++l)
+    vertices[l] = cell->vertex(l);
+
+  for (unsigned int point=0; point<unit_points.size(); ++point)
+    {
+      const double xi  = unit_points[point](0);
+      const double eta = unit_points[point](1);
+      const double zeta= unit_points[point](2);
+
+      const double t1 = vertices[3](1)*vertices[4](2);
+      const double t2 = xi*xi;
+      const double t3 = vertices[5](1)*t2;
+      const double t4 = vertices[3](2)*eta;
+      const double t6 = vertices[7](1)*zeta;
+      const double t7 = t2*vertices[3](2);
+      const double t9 = t2*vertices[2](2);
+      const double t11 = t2*vertices[1](2);
+      const double t13 = vertices[4](1)*vertices[3](2);
+      const double t14 = vertices[4](1)*vertices[0](2);
+      const double t15 = t2*vertices[0](2);
+      const double t17 = vertices[0](1)*vertices[3](2);
+      const double t18 = vertices[1](1)*t2;
+      const double t20 = vertices[0](1)*vertices[7](2);
+      const double t21 = xi*eta;
+      const double t22 = t20*t21;
+      const double t24 = t1-t3*t4-t6*t7+t6*t9-t6*t11-t13+t14+t6*t15+t17+t18*t4-2.0*t22;
+      const double t25 = vertices[0](1)*vertices[6](2);
+      const double t26 = t25*t21;
+      const double t28 = 2.0*t17*t21;
+      const double t29 = vertices[0](1)*vertices[2](2);
+      const double t30 = t29*t21;
+      const double t31 = vertices[6](1)*t2;
+      const double t32 = zeta*vertices[1](2);
+      const double t34 = vertices[3](1)*vertices[0](2);
+      const double t35 = vertices[0](1)*vertices[4](2);
+      const double t36 = vertices[6](2)*eta;
+      const double t38 = vertices[5](1)*xi;
+      const double t39 = t38*t4;
+      const double t40 = vertices[2](2)*eta;
+      const double t42 = vertices[4](1)*t2;
+      const double t43 = zeta*vertices[3](2);
+      const double t45 = zeta*vertices[2](2);
+      const double t47 = t26+t28-t30+t31*t32-t34-t35-t3*t36+t39+t3*t40+t42*t43-t42*t45;
+      const double t50 = zeta*vertices[0](2);
+      const double t52 = vertices[7](2)*eta;
+      const double t57 = vertices[4](1)*zeta;
+      const double t58 = vertices[3](2)*xi;
+      const double t59 = t57*t58;
+      const double t61 = vertices[2](2)*xi;
+      const double t62 = t57*t61;
+      const double t63 = vertices[1](2)*xi;
+      const double t64 = t57*t63;
+      const double t68 = t42*t32-t42*t50-t42*t52+t42*t36+t42*t4-t42*t40-2.0*t59+t62-t64+2.0*t6*t58-t6*t61;
+      const double t69 = t6*t63;
+      const double t70 = vertices[0](2)*xi;
+      const double t71 = t6*t70;
+      const double t75 = vertices[3](1)*vertices[7](2);
+      const double t76 = xi*zeta;
+      const double t79 = vertices[3](1)*vertices[6](2);
+      const double t81 = vertices[3](1)*vertices[5](2);
+      const double t82 = t81*t76;
+      const double t83 = vertices[3](1)*t2;
+      const double t84 = t83*vertices[5](2);
+      const double t85 = t1*t76;
+      const double t87 = vertices[2](1)*xi;
+      const double t88 = eta*vertices[4](2);
+      const double t89 = t87*t88;
+      const double t90 = eta*vertices[0](2);
+      const double t91 = t87*t90;
+      const double t92 = t69-2.0*t71+t31*t43-t31*t45-2.0*t75*t76+t79*t76-t82-t84+2.0*t85-t89+t91;
+      const double t95 = vertices[6](1)*xi;
+      const double t97 = t95*t90;
+      const double t98 = vertices[0](1)*t2;
+      const double t104 = vertices[1](1)*xi;
+      const double t105 = t104*t52;
+      const double t107 = t104*t4;
+      const double t109 = t95*t88-t97+t98*t52-t98*t36-t98*t4+t98*t40-t18*t52+t105+t18*t36-t107-t18*t40;
+      const double t111 = 2.0*t57*t70;
+      const double t119 = vertices[6](2)*zeta;
+      const double t121 = vertices[5](2)*zeta;
+      const double t123 = vertices[4](2)*zeta;
+      const double t125 = t111-t31*t50-t3*t43+t3*t45-t3*t32+t3*t50+t3*t52-t38*t52-t83*t119+t83*t121-t83*t123;
+      const double t127 = vertices[3](1)*eta;
+      const double t128 = vertices[5](2)*xi;
+      const double t129 = t127*t128;
+      const double t130 = vertices[4](2)*xi;
+      const double t131 = t127*t130;
+      const double t133 = t127*t63;
+      const double t134 = t83*vertices[0](2);
+      const double t136 = 2.0*t127*t70;
+      const double t137 = vertices[2](1)*t2;
+      const double t138 = eta*vertices[5](2);
+      const double t140 = t87*vertices[0](2);
+      const double t142 = eta*vertices[1](2);
+      const double t145 = vertices[7](1)*eta;
+      const double t146 = t145*vertices[4](2);
+      const double t147 = -t129+2.0*t131+t133-t134-t136-t137*t138-t140+t137*t88+t137*t142-t137*t90+t146;
+      const double t148 = t14*xi;
+      const double t150 = t6*vertices[3](2);
+      const double t159 = vertices[7](2)*zeta;
+      const double t161 = -2.0*t148-t150+t31*t138-t31*t88-t31*t142+t31*t90+t83*t138-t83*t88-t83*t142+t83*t90+t83*t159;
+      const double t165 = t127*vertices[0](2);
+      const double t166 = vertices[0](1)*vertices[5](2);
+      const double t167 = t166*xi;
+      const double t168 = t1*xi;
+      const double t170 = vertices[4](1)*vertices[7](2);
+      const double t173 = vertices[4](1)*vertices[6](2);
+      const double t175 = t13*t21;
+      const double t177 = vertices[4](1)*vertices[2](2);
+      const double t178 = t177*t21;
+      const double t180 = t6*vertices[0](2);
+      const double t183 = t165-t167-2.0*t168+2.0*t170*t21-t173*t21-2.0*t175+t178-t137*t159+t180+t87*t159+t137*t119;
+      const double t186 = t87*t123;
+      const double t188 = t104*t159;
+      const double t192 = t104*t123;
+      const double t195 = -t137*t121+t137*t123-t186+t18*t159-t188-t18*t119+t18*t121-t18*t123+t192-t98*t159+t98*t119;
+      const double t200 = t95*t50;
+      const double t201 = t38*t43;
+      const double t202 = t38*t50;
+      const double t203 = t145*t70;
+      const double t205 = t20*t76;
+      const double t207 = t25*t76;
+      const double t208 = t166*t76;
+      const double t210 = 2.0*t35*t76;
+      const double t211 = -t98*t121+t98*t123-t95*t43+t200+t201-t202+2.0*t203+2.0*t205-t207+t208-t210;
+      const double t212 = t2*vertices[5](2);
+      const double t214 = t2*vertices[4](2);
+      const double t221 = t145*t63;
+      const double t222 = t42*vertices[3](2);
+      const double t223 = t170*eta;
+      const double t224 = t145*vertices[0](2);
+      const double t225 = t38*vertices[0](2);
+      const double t226 = -t145*t212+t145*t214+t145*t11-t145*t15+t145*t128-2.0*t145*t130-t221-t222-t223-t224+t225;
+      const double t229 = vertices[4](1)*vertices[1](2);
+      const double t230 = t229*xi;
+      const double t231 = t98*vertices[4](2);
+      const double t232 = t177*xi;
+      const double t233 = t81*xi;
+      const double t234 = t83*vertices[1](2);
+      const double t235 = t127*vertices[4](2);
+      const double t236 = t3*vertices[0](2);
+      const double t237 = t42*vertices[2](2);
+      const double t238 = t104*vertices[4](2);
+      const double t239 = t17*eta;
+      const double t240 = t29*xi;
+      const double t241 = t230-t231-t232+t233+t234-t235-t236+t237-t238-t239+t240;
+      const double t242 = t3*vertices[3](2);
+      const double t243 = t3*vertices[2](2);
+      const double t244 = t3*vertices[1](2);
+      const double t245 = t20*eta;
+      const double t246 = t17*xi;
+      const double t248 = t104*vertices[3](2);
+      const double t249 = t20*zeta;
+      const double t250 = t35*xi;
+      const double t252 = t35*zeta;
+      const double t253 = t83*vertices[4](2);
+      const double t254 = t137*vertices[5](2);
+      const double t255 = t242-t243+t244+t245-2.0*t246+t248-t249+2.0*t250+t252+t253+t254;
+      const double t257 = t137*vertices[4](2);
+      const double t258 = t137*vertices[1](2);
+      const double t259 = t137*vertices[0](2);
+      const double t260 = t18*vertices[5](2);
+      const double t261 = t18*vertices[4](2);
+      const double t262 = t98*vertices[5](2);
+      const double t263 = t75*zeta;
+      const double t264 = t1*zeta;
+      const double t265 = vertices[3](1)*vertices[1](2);
+      const double t266 = t265*xi;
+      const double t267 = t34*xi;
+      const double t269 = t87*vertices[4](2);
+      const double t270 = -t257-t258+t259-t260+t261+t262+t263-t264-t266+2.0*t267+t269;
+      const double t271 = t18*vertices[3](2);
+      const double t272 = t18*vertices[2](2);
+      const double t273 = t98*vertices[3](2);
+      const double t274 = t98*vertices[2](2);
+      const double t275 = t42*vertices[1](2);
+      const double t276 = t42*vertices[0](2);
+      const double t277 = t38*vertices[3](2);
+      const double t278 = t57*vertices[3](2);
+      const double t279 = t57*vertices[0](2);
+      const double t280 = t13*xi;
+      const double t282 = t13*eta;
+      const double t283 = -t271+t272+t273-t274-t275+t276-t277+t278-t279+2.0*t280+t282;
+      const double t288 = vertices[1](0)*eta;
+      const double t289 = zeta*zeta;
+      const double t290 = t288*t289;
+      const double t292 = vertices[0](0)*vertices[4](1);
+      const double t294 = vertices[7](0)*vertices[1](2);
+      const double t295 = zeta*vertices[2](1);
+      const double t296 = t295*xi;
+      const double t298 = eta*eta;
+      const double t299 = vertices[1](2)*t298;
+      const double t300 = vertices[4](0)*vertices[6](1);
+      const double t301 = t300*xi;
+      const double t303 = vertices[0](0)*eta;
+      const double t304 = t303*t289;
+      const double t306 = vertices[2](0)*zeta;
+      const double t307 = t306*vertices[0](1);
+      const double t308 = t2*vertices[7](2);
+      const double t309 = t308*eta;
+      const double t311 = t32*xi;
+      const double t314 = vertices[0](0)*vertices[7](1);
+      const double t315 = t43*xi;
+      const double t319 = t306*vertices[4](1);
+      const double t321 = t2*vertices[6](2);
+      const double t322 = t321*eta;
+      const double t324 = vertices[3](0)*vertices[1](1);
+      const double t325 = t2*eta;
+      const double t326 = t325*vertices[5](2);
+      const double t330 = vertices[3](1)*zeta;
+      const double t331 = vertices[4](0)*t2;
+      const double t332 = t331*vertices[0](2);
+      const double t334 = vertices[0](0)*vertices[3](1);
+      const double t336 = -t290*t148-t292*t52+t294*t296-t299*t301-t304*t232-t307*t309+2.0*t292*t311+2.0*t314*t315-t292*t61+t319*t309-t319*t322+t324*t326+t306*t244+t292*t9+t330*t332+t334*t128;
+      const double t337 = vertices[2](0)*t289;
+      const double t340 = vertices[1](0)*t298;
+      const double t341 = t340*zeta;
+      const double t344 = t95*vertices[4](2);
+      const double t346 = t95*vertices[0](2);
+      const double t348 = vertices[7](0)*vertices[0](2);
+      const double t349 = t325*vertices[5](1);
+      const double t353 = vertices[1](1)*zeta;
+      const double t354 = vertices[0](0)*vertices[5](2);
+      const double t355 = t354*xi;
+      const double t358 = vertices[0](0)*t289;
+      const double t362 = t138*zeta;
+      const double t363 = vertices[2](0)*xi;
+      const double t364 = t363*vertices[4](1);
+      const double t368 = vertices[7](1)*vertices[2](2)*xi;
+      const double t370 = vertices[1](1)*eta;
+      const double t371 = vertices[3](0)*vertices[5](2);
+      const double t372 = t371*xi;
+      const double t374 = t337*t280-t292*t63+t341*t269-t341*t140-t341*t344+t341*t346-t348*t349+t303*t232+t290*t280+2.0*t353*t355+t358*t232-t292*t7-t340*t269+2.0*t362*t364+t304*t368-t370*t372;
+      const double t378 = vertices[4](0)*vertices[0](2);
+      const double t380 = vertices[7](0)*eta;
+      const double t381 = t380*t289;
+      const double t384 = vertices[7](1)*vertices[1](2)*xi;
+      const double t387 = t303*zeta;
+      const double t390 = vertices[5](1)*eta;
+      const double t391 = t390*zeta;
+      const double t392 = vertices[1](0)*xi;
+      const double t393 = t392*vertices[4](2);
+      const double t396 = vertices[2](1)*t289;
+      const double t397 = vertices[0](0)*vertices[7](2);
+      const double t398 = t397*eta;
+      const double t400 = vertices[7](0)*zeta;
+      const double t401 = t400*vertices[1](1);
+      const double t402 = t138*xi;
+      const double t408 = t314*eta;
+      const double t409 = zeta*t2;
+      const double t410 = t409*vertices[3](2);
+      const double t412 = t409*vertices[2](2);
+      const double t415 = t340*t140+t340*t344+t378*t137+t381*t225-t304*t384-t340*t346+2.0*t387*t280+2.0*t391*t393+t396*t398-2.0*t401*t402+t303*t243+t303*t222-t303*t237+t408*t410-t408*t412+t303*t230;
+      const double t416 = t303*vertices[6](1);
+      const double t419 = vertices[4](0)*vertices[2](1);
+      const double t420 = t419*xi;
+      const double t422 = vertices[0](0)*vertices[1](2);
+      const double t424 = vertices[1](0)*t289;
+      const double t426 = vertices[1](0)*zeta;
+      const double t427 = t426*vertices[5](1);
+      const double t429 = vertices[0](0)*vertices[5](1);
+      const double t431 = vertices[5](0)*xi;
+      const double t432 = t431*vertices[0](2);
+      const double t436 = xi*vertices[7](2);
+      const double t437 = t436*eta;
+      const double t440 = vertices[1](0)*vertices[4](1);
+      const double t441 = t440*zeta;
+      const double t443 = vertices[5](1)*t298;
+      const double t444 = t443*zeta;
+      const double t445 = vertices[0](0)*vertices[2](2);
+      const double t446 = t445*xi;
+      const double t450 = vertices[3](0)*eta;
+      const double t451 = t450*vertices[0](2);
+      const double t457 = -t416*t410+t416*t412+t299*t420-t422*t145+t424*t148+t427*t309-t429*t9+t330*t432-2.0*t303*t280-2.0*t427*t437+t441*t322+t444*t446+2.0*t303*t248+2.0*t295*t451-t427*t322+2.0*t422*t127;
+      const double t460 = vertices[4](0)*vertices[0](1);
+      const double t464 = t303*vertices[4](1);
+      const double t467 = vertices[7](1)*vertices[0](2);
+      const double t469 = vertices[0](0)*vertices[1](1);
+      const double t470 = vertices[6](2)*xi;
+      const double t471 = t470*eta;
+      const double t480 = t76*vertices[0](1);
+      const double t486 = vertices[1](1)*t298;
+      const double t487 = t397*zeta;
+      const double t489 = t45*xi;
+      const double t492 = -t138*t460-t441*t309-t303*t242-2.0*t464*t311+t424*t467+t469*t471-t429*t58+t292*t43+2.0*t292*t58+t292*t4-t469*t58-2.0*t142*vertices[5](0)*t480-2.0*t408*t315+t429*t7+t486*t487+2.0*t408*t489;
+      const double t494 = xi*vertices[3](1);
+      const double t495 = t494*eta;
+      const double t498 = vertices[4](0)*t298;
+      const double t499 = t38*vertices[7](2);
+      const double t501 = vertices[4](0)*eta;
+      const double t504 = t426*vertices[0](1);
+      const double t505 = t58*eta;
+      const double t509 = vertices[0](0)*vertices[6](1);
+      const double t510 = t509*xi;
+      const double t512 = t426*vertices[2](1);
+      const double t513 = t21*vertices[4](2);
+      const double t517 = vertices[0](0)*t298;
+      const double t518 = t517*vertices[3](2);
+      const double t520 = t303*vertices[4](2);
+      const double t522 = vertices[3](0)*zeta;
+      const double t523 = t522*vertices[0](1);
+      const double t525 = vertices[0](0)*vertices[6](2);
+      const double t526 = t525*xi;
+      const double t528 = vertices[1](0)*vertices[6](1);
+      const double t530 = vertices[6](0)*eta;
+      const double t531 = t330*vertices[0](2);
+      const double t533 = t363*vertices[4](2);
+      const double t535 = 2.0*t45*vertices[1](0)*t495+t498*t499+t501*t271-t501*t272+2.0*t504*t505-t426*t222+t299*t510-2.0*t512*t513+t387*t237+t295*t518+t295*t520+t523*t309-t444*t526+t528*t315+t530*t531-t443*t533;
+      const double t537 = vertices[0](0)*zeta;
+      const double t541 = vertices[0](1)*vertices[6](0);
+      const double t544 = vertices[4](0)*vertices[2](2);
+      const double t545 = t544*xi;
+      const double t548 = vertices[4](1)*t298;
+      const double t549 = t548*zeta;
+      const double t551 = vertices[7](0)*vertices[5](2)*xi;
+      const double t553 = vertices[0](1)*t289;
+      const double t554 = t294*xi;
+      const double t557 = vertices[5](0)*eta;
+      const double t558 = t557*t289;
+      const double t560 = t522*t298;
+      const double t563 = vertices[7](1)*vertices[4](2);
+      const double t566 = vertices[3](0)*vertices[1](2);
+      const double t567 = t566*xi;
+      const double t569 = vertices[1](1)*t289;
+      const double t571 = t537*t248-t537*t242-t443*t446+t541*t315-t498*t277+2.0*t370*t545-t549*t551-t553*t554+t549*t554-t558*t250-t560*t269+t537*t243+t340*t563+t537*t222+t390*t567+t569*t432;
+      const double t572 = vertices[2](0)*vertices[1](2);
+      const double t573 = t31*zeta;
+      const double t575 = vertices[3](0)*t289;
+      const double t576 = t575*vertices[7](2);
+      const double t578 = t522*vertices[0](2);
+      const double t582 = t470*zeta;
+      const double t584 = t358*vertices[7](2);
+      const double t587 = vertices[3](0)*vertices[4](2);
+      const double t594 = vertices[7](0)*t289;
+      const double t595 = t594*vertices[0](2);
+      const double t597 = vertices[4](0)*t289;
+      const double t598 = t597*vertices[0](1);
+      const double t600 = t104*vertices[7](2);
+      const double t603 = -t572*t573-t390*t576-t443*t578+t501*t274-t537*t237-t469*t582+t390*t584+t560*t140+t486*t587-2.0*t387*t248+t424*t13+t560*t344-t560*t346+t370*t595-t138*t598-t498*t600+t443*t526;
+      const double t607 = vertices[4](0)*vertices[1](1);
+      const double t608 = t607*xi;
+      const double t614 = t587*zeta;
+      const double t618 = t501*vertices[6](1);
+      const double t619 = t409*vertices[0](2);
+      const double t623 = t450*vertices[4](2);
+      const double t626 = t530*zeta;
+      const double t629 = t330*t298;
+      const double t634 = 2.0*t362*t608+t498*t248+t387*t242+t390*t533-2.0*t390*t614-t387*t243-t618*t619-t387*t222+t306*t167+3.0*t353*t623-t626*t243-t340*t170-t629*t526-t45*t408+t626*t244-t626*t236;
+      const double t639 = vertices[6](0)*t298;
+      const double t640 = t639*zeta;
+      const double t641 = t20*xi;
+      const double t646 = t324*zeta;
+      const double t651 = t380*zeta;
+      const double t654 = t95*zeta;
+      const double t658 = t522*vertices[5](1);
+      const double t660 = -t340*t467+t306*t276-t626*t222+t460*t309+t640*t641+t626*t237-t640*t246+t537*t223+t646*t322+t522*t275-t522*t276-t537*t146+2.0*t651*t148+t422*t654+2.0*t651*t140+t658*t309;
+      const double t662 = vertices[7](1)*vertices[3](2);
+      const double t663 = t662*xi;
+      const double t667 = t530*t289;
+      const double t672 = vertices[3](0)*vertices[7](2);
+      const double t674 = t522*vertices[6](1);
+      const double t675 = t325*vertices[0](2);
+      const double t677 = t498*zeta;
+      const double t679 = vertices[2](2)*t289;
+      const double t680 = t679*eta;
+      const double t681 = t431*vertices[0](1);
+      const double t685 = t295*t298;
+      const double t690 = eta*vertices[4](1);
+      const double t691 = t690*vertices[0](2);
+      const double t693 = t424*t663+t340*t34-t390*t545-t667*t232-t358*t368-2.0*t658*t437-t569*t672+t674*t675+t677*t277-t680*t681-t658*t322+t358*t384-t685*t551-2.0*t324*t130+t537*t277+t522*t691;
+      const double t695 = vertices[6](0)*xi;
+      const double t696 = t695*vertices[4](2);
+      const double t698 = t431*vertices[3](1);
+      const double t702 = t557*zeta;
+      const double t705 = vertices[3](1)*t289;
+      const double t706 = t705*eta;
+      const double t708 = t522*eta;
+      const double t710 = vertices[3](0)*vertices[0](2);
+      const double t714 = vertices[3](0)*vertices[2](1);
+      const double t715 = t714*zeta;
+      const double t718 = t25*xi;
+      const double t721 = vertices[1](2)*vertices[6](0);
+      const double t722 = t21*vertices[4](1);
+      const double t725 = vertices[3](0)*vertices[7](1);
+      const double t726 = t725*zeta;
+      const double t727 = t325*vertices[4](2);
+      const double t730 = -t486*t397-t486*t696+t680*t698-2.0*t537*t280+2.0*t702*t280-t706*t554+t708*t276-t486*t710+2.0*t651*t167+2.0*t715*t513+t340*t718-t523*t322-t721*t722-t537*t282+t726*t727-t607*t7;
+      const double t734 = t36*t289;
+      const double t735 = t363*vertices[7](1);
+      const double t738 = t306*t298;
+      const double t740 = vertices[5](0)*t298;
+      const double t741 = t740*zeta;
+      const double t743 = t370*t289;
+      const double t744 = t695*vertices[0](2);
+      const double t746 = vertices[5](2)*t298;
+      const double t747 = t746*zeta;
+      const double t748 = t695*vertices[0](1);
+      const double t750 = t467*xi;
+      const double t754 = vertices[0](0)*vertices[3](2);
+      const double t756 = t337*eta;
+      const double t758 = vertices[4](1)*t289;
+      const double t759 = t758*vertices[0](2);
+      const double t761 = t758*vertices[3](2);
+      const double t764 = vertices[2](0)*vertices[0](1);
+      const double t766 = t390*t578-t734*t735-t522*t14-t738*t499+t741*t718+t743*t744-t747*t748-t558*t750+t741*t246+t738*t277-t353*t754-t756*t280-t557*t759+t557*t761+t460*t63-t764*t130;
+      const double t768 = vertices[7](0)*vertices[1](1);
+      const double t770 = vertices[3](0)*vertices[4](1);
+      const double t771 = t770*zeta;
+      const double t776 = zeta*vertices[0](1);
+      const double t777 = t776*vertices[3](2);
+      const double t781 = t594*vertices[0](1);
+      const double t784 = t594*vertices[3](2);
+      const double t786 = t370*zeta;
+      const double t791 = vertices[1](2)*t289;
+      const double t793 = t460*t61+t768*t727-t771*t309+t337*t14-t337*t467+t340*t13+t639*t777+t771*t322+t679*t464-t36*t781+t639*t180-t370*t784+2.0*t786*t432-t639*t531+t314*t88+t791*t748;
+      const double t795 = t6*vertices[4](2);
+      const double t797 = t695*vertices[4](1);
+      const double t799 = t334*eta;
+      const double t812 = vertices[6](2)*t298;
+      const double t813 = t812*zeta;
+      const double t814 = vertices[3](0)*vertices[5](1);
+      const double t815 = t814*xi;
+      const double t818 = vertices[7](1)*t289;
+      const double t819 = t818*vertices[3](2);
+      const double t822 = -t639*t795+t747*t797+2.0*t45*t799+t721*t21*vertices[0](1)-t558*t230+t558*t232-t607*t61+t738*t600-t738*t248+t340*t20-t340*t17+t558*t663+t813*t815-t558*t368-t557*t819-t381*t346;
+      const double t823 = t306*eta;
+      const double t825 = vertices[5](0)*vertices[1](2);
+      const double t826 = t31*eta;
+      const double t829 = vertices[1](0)*vertices[7](1);
+      const double t830 = t829*eta;
+      const double t835 = t537*vertices[5](1);
+      const double t846 = vertices[4](0)*vertices[7](1);
+      const double t847 = t846*eta;
+      const double t850 = t823*t275+t825*t826-t530*t761-t830*t410+t756*t148-t710*t573-t823*t276+t835*t322+2.0*t646*t437+t569*t587-t639*t249-t639*t278+t530*t759-t646*t309+t756*t168+t626*t242+2.0*t847*t315;
+      const double t857 = vertices[0](0)*vertices[2](1);
+      const double t858 = t857*xi;
+      const double t863 = t50*xi;
+      const double t866 = t690*t289;
+      const double t873 = vertices[1](0)*vertices[5](1);
+      const double t875 = vertices[1](0)*vertices[3](1);
+      const double t882 = t57*vertices[7](2);
+      const double t884 = -2.0*t557*t278-t747*t858+2.0*t557*t279+t829*t90-2.0*t847*t863+t866*t372-t557*t280-t557*t240+t557*t248-2.0*t847*t489-t873*t70-2.0*t875*t90-t740*t718+t740*t641+2.0*t847*t311-t740*t882;
+      const double t885 = t390*t289;
+      const double t886 = vertices[4](0)*vertices[1](2);
+      const double t887 = t886*xi;
+      const double t891 = vertices[6](1)*eta;
+      const double t892 = t891*t289;
+      const double t893 = t363*vertices[7](2);
+      const double t895 = vertices[1](0)*vertices[0](1);
+      const double t898 = vertices[0](1)*t298;
+      const double t899 = t898*vertices[7](2);
+      const double t902 = t557*vertices[7](1);
+      const double t909 = t587*xi;
+      const double t913 = t885*t887-t740*t246-t528*t326+t892*t893+t895*t128-t829*t50+t306*t899+t740*t240+t902*t410-t829*t88+t390*t887-t740*t180+t618*t410+t740*t531+2.0*t391*t909-t618*t412;
+      const double t915 = t409*vertices[1](2);
+      const double t917 = t818*vertices[0](2);
+      const double t919 = vertices[6](1)*t298;
+      const double t920 = t919*zeta;
+      const double t924 = vertices[3](0)*t2;
+      const double t925 = t924*vertices[1](2);
+      const double t931 = vertices[3](0)*vertices[6](2);
+      const double t932 = t931*xi;
+      const double t934 = vertices[1](0)*vertices[2](1);
+      const double t937 = t557*vertices[4](1);
+      const double t946 = t618*t915+t557*t917-t920*t554+t528*t727-t875*t326+t690*t925+t501*t277-3.0*t501*t248+t440*t70-t866*t932+t934*t70+t138*t420-2.0*t937*t489-2.0*t702*t140-2.0*t702*t148+2.0*t937*t311;
+      const double t949 = t429*eta;
+      const double t950 = t130*zeta;
+      const double t961 = vertices[7](1)*vertices[5](2)*xi;
+      const double t970 = t431*vertices[7](2);
+      const double t974 = 2.0*t501*t246-2.0*t949*t950-2.0*t902*t315-2.0*t902*t311+2.0*t902*t489+t875*t727+t677*t961+t740*t278-t747*t364-2.0*t702*t248-t501*t240-t847*t410+t740*t249-t920*t970-t885*t393-t740*t777;
+      const double t977 = t363*vertices[0](1);
+      const double t981 = t537*vertices[3](2);
+      const double t984 = t324*xi;
+      const double t986 = t498*vertices[7](2);
+      const double t990 = xi*vertices[7](1);
+      const double t991 = t990*eta;
+      const double t996 = t501*zeta;
+      const double t999 = t61*eta;
+      const double t1002 = t898*zeta;
+      const double t1005 = t747*t977+t746*t301-t337*t13-t486*t981-t741*t641-t813*t984+t295*t986+t847*t412+t607*t9+t825*t991+t575*t230-3.0*t875*t950-2.0*t996*t167-2.0*t469*t999-t1002*t372+t575*t368;
+      const double t1010 = t557*vertices[6](1);
+      const double t1012 = vertices[7](0)*vertices[0](1);
+      const double t1026 = -t575*t384-t892*t533-t501*t273-t306*t260+t1010*t412+t1012*t326+t651*t274+t306*t261+t522*t245-t396*t587-2.0*t996*t246+t306*t262-2.0*t426*t167-t306*t231+t873*t9+t892*t545;
+      const double t1031 = t306*vertices[6](1);
+      const double t1037 = t400*vertices[3](1);
+      const double t1040 = t575*vertices[4](1);
+      const double t1042 = t348*xi;
+      const double t1044 = t390*xi;
+      const double t1051 = -t522*t240-2.0*t996*t277-t1031*t326+t747*t510-t501*t225+t679*t681+t501*t167+t138*t1037+t501*t180-t138*t1040-t743*t1042-t294*t1044+4.0*t996*t248+t501*t140+t396*t672+t891*t595;
+      const double t1053 = t575*eta;
+      const double t1058 = t325*vertices[1](2);
+      const double t1069 = t486*zeta;
+      const double t1072 = t1031*t727+t1053*t232+t440*t7+t902*t915+t290*t750+t1031*t1058-t741*t240-t557*t230-t1053*t230-t557*t180+t557*t232-t440*t9+t440*t61+t45*t847+t557*t148+t1069*t545-t1010*t410;
+      const double t1084 = t557*vertices[0](1);
+      const double t1085 = t159*xi;
+      const double t1089 = t321*zeta;
+      const double t1091 = t548*vertices[7](2);
+      const double t1095 = vertices[3](0)*vertices[2](2);
+      const double t1096 = t1095*zeta;
+      const double t1102 = t212*zeta;
+      const double t1104 = -t1031*t675-t1053*t368+t738*t266+t440*t52-t885*t545-t1010*t915+t370*t355+t1053*t384-2.0*t1084*t1085+t1069*t696+t875*t1089-t306*t1091-2.0*t440*t58-2.0*t1096*t370*xi+2.0*t1096*t1044-t875*t1102;
+      const double t1105 = vertices[7](1)*t298;
+      const double t1106 = t1105*vertices[0](2);
+      const double t1109 = vertices[7](0)*vertices[4](2);
+      const double t1110 = t1109*xi;
+      const double t1115 = t594*vertices[3](1);
+      const double t1119 = vertices[3](1)*t298;
+      const double t1120 = t1119*vertices[0](2);
+      const double t1122 = vertices[4](0)*zeta;
+      const double t1123 = t1122*vertices[3](2);
+      const double t1127 = t214*zeta;
+      const double t1129 = t557*vertices[2](1);
+      const double t1130 = t308*zeta;
+      const double t1133 = t557*vertices[1](1);
+      const double t1139 = -t306*t1106+t337*t224+t486*t1110+2.0*t823*t225+t486*t348+t36*t1115-2.0*t440*t4+t306*t1120+t919*t1123-2.0*t823*t167+t875*t1127+t1129*t1130+t875*t402-2.0*t1133*t950+t1133*t1089-3.0*t875*t513;
+      const double t1141 = t396*eta;
+      const double t1142 = vertices[7](0)*vertices[3](2);
+      const double t1143 = t1142*xi;
+      const double t1145 = t1105*vertices[4](2);
+      const double t1151 = t90*xi;
+      const double t1154 = t79*xi;
+      const double t1156 = t306*vertices[7](1);
+      const double t1168 = -t1141*t1143+t306*t1145-t1129*t1089-2.0*t1129*t1085-t895*t52+2.0*t875*t1151+t756*t1154+t1156*t675+t708*t244-t1133*t1130-t708*t236+2.0*t1133*t1085+t560*t718-t560*t240+t895*t58+2.0*t895*t4;
+      const double t1180 = t1122*vertices[7](1);
+      const double t1184 = t299*zeta;
+      const double t1189 = t145*t289;
+      const double t1195 = 4.0*t708*t230-t895*t61-t873*t7-2.0*t708*t232-t45*t464-2.0*t708*t148+t934*t326-t934*t727-t746*t1180+2.0*t875*t1085-t1184*t510-2.0*t708*t140-t486*t1109-t1189*t526+t667*t600+2.0*t996*t225+t396*t744;
+      const double t1199 = t128*zeta;
+      const double t1204 = t431*vertices[3](2);
+      const double t1207 = t392*vertices[7](2);
+      const double t1210 = t409*vertices[2](1);
+      const double t1220 = -t875*t582+2.0*t875*t1199-t575*t232-t330*t545-t295*t1204-t607*t70+t920*t1207-t677*t384-t294*t1210+t566*t573+2.0*t306*t235-t501*t531+t469*t61-t306*t233+t575*t600+t522*t146;
+      const double t1223 = t400*vertices[0](2);
+      const double t1225 = t1122*vertices[3](1);
+      const double t1234 = vertices[3](0)*vertices[0](1);
+      const double t1237 = t378*xi;
+      const double t1241 = t501*t289;
+      const double t1242 = t95*vertices[3](2);
+      const double t1244 = t409*vertices[3](1);
+      const double t1247 = 2.0*t522*t148+t390*t1223-2.0*t138*t1225-t138*t1115+t558*t168+t288*t14+t1184*t364+t522*t140+t738*t168+t1234*t1089+t426*t17-2.0*t330*t1237+t306*t168-t1241*t1242+t294*t1244-t381*t167;
+      const double t1254 = t142*t289;
+      const double t1255 = vertices[3](0)*vertices[6](1);
+      const double t1256 = t1255*xi;
+      const double t1261 = t1122*vertices[7](2);
+      const double t1263 = t563*xi;
+      const double t1266 = vertices[5](0)*vertices[0](1);
+      const double t1271 = t314*t412+t756*t663+t1241*t346-t756*t750-t306*t267-t1254*t1256+t1241*t277-t1241*t225+t1254*t815-t919*t1261+t740*t1263+t891*t614+t1266*t437+t743*t1204+t337*t282-t337*t691;
+      const double t1273 = t75*xi;
+      const double t1276 = t548*vertices[3](2);
+      const double t1284 = t898*vertices[3](2);
+      const double t1287 = t87*eta;
+      const double t1291 = t710*xi;
+      const double t1295 = t873*t58+t337*t1273+t557*t238+t306*t1276-t337*t1154+t340*t180+t557*t249+t390*t784+t348*t1210-t358*t230-t306*t1284-t557*t250+2.0*t422*t1287-t823*t244-t443*t1291+t337*t233+t651*t257;
+      const double t1302 = t501*vertices[0](1);
+      const double t1308 = t95*eta;
+      const double t1313 = vertices[4](0)*vertices[6](2);
+      const double t1314 = t1313*xi;
+      const double t1321 = vertices[0](1)*eta;
+      const double t1322 = t1321*t289;
+      const double t1326 = t469*t52+t1302*t1089-t337*t168+t823*t236-2.0*t440*t43-t422*t1308+t1184*t748+t791*t1256-t738*t641+t444*t1314+t306*t277-t746*t771-2.0*t362*t420+t734*t364+t1322*t545+2.0*t440*t50;
+      const double t1327 = vertices[5](0)*vertices[1](1);
+      const double t1338 = t422*zeta;
+      const double t1344 = t288*zeta;
+      const double t1350 = t1327*t309-t1184*t797+2.0*t288*t252+t738*t246-2.0*t823*t230-t1084*t1089-t1141*t744-t875*t1130-2.0*t1338*t1287-t740*t750+t381*t718+t1189*t932-4.0*t1344*t280-t829*t1151-t626*t257-t626*t258;
+      const double t1366 = t45*t298;
+      const double t1367 = t392*vertices[7](1);
+      const double t1371 = -t290*t1154-t895*t1085+t522*t236-t679*t1302-t1344*t237+t895*t582-t626*t260+t626*t259+t290*t233-2.0*t440*t437+t306*t266-t875*t214-t934*t212+t1366*t1367+t626*t261-t290*t168;
+      const double t1378 = t875*eta;
+      const double t1387 = vertices[1](1)*vertices[6](0);
+      const double t1390 = -t1184*t977+t440*t471+t934*t1130-t651*t234-t791*t815-t651*t253+t1378*t1130-t522*t244+t566*t3-t1378*t1089-t768*t326+t934*t214+t651*t134-t679*t1012-t1387*t315-t651*t254;
+      const double t1393 = vertices[5](0)*t2;
+      const double t1394 = t1393*vertices[1](2);
+      const double t1398 = t1105*zeta;
+      const double t1415 = t330*t1394+t340*t168-t651*t259+t1398*t545-2.0*t523*t437+t919*t487-t306*t17-t340*t267+t530*t819+t1327*t412+t1327*t7+t740*t795-t651*t261-2.0*t786*t355+t443*t614+2.0*t523*t999;
+      const double t1421 = t306*vertices[3](1);
+      const double t1431 = t498*vertices[3](1);
+      const double t1437 = -t566*t42+t306*t13-3.0*t522*t230+t651*t260+2.0*t1421*t402+t1387*t410+t522*t232-t651*t262-t522*t223+t651*t231-2.0*t1421*t513+t45*t1431-t1241*t718+t746*t364-t306*t14+t324*t1130;
+      const double t1440 = t400*vertices[0](1);
+      const double t1443 = t142*xi;
+      const double t1462 = -t522*t224+t812*t1440-t522*t225-2.0*t1421*t1443-t902*t619+2.0*t1421*t1151+t522*t167-t651*t272-2.0*t288*t279-2.0*t1378*t1085+t1266*t58+t380*t252+t509*t410-2.0*t651*t233-t1254*t748+t791*t698;
+      const double t1483 = t334*t159-2.0*t334*t130+t829*t326+t517*t277-t829*t727+t295*t754+t1254*t510-t334*t123+2.0*t651*t168+t444*t744-t829*t402+t541*t727+t288*t242+2.0*t651*t266+t1012*t311+t426*t254-t426*t257;
+      const double t1508 = -t919*t1223+t639*t264+2.0*t829*t513-t341*t168+t1322*t554-2.0*t651*t267+t919*t578-2.0*t651*t269-2.0*t319*t437-t396*t372-t381*t1154+t341*t267-t569*t1237-t486*t526+2.0*t319*t505-t1327*t9;
+      const double t1511 = t705*vertices[7](2);
+      const double t1514 = t695*vertices[3](1);
+      const double t1521 = t768*xi;
+      const double t1524 = t292*zeta;
+      const double t1527 = t705*vertices[4](2);
+      const double t1530 = t626*t253+t340*t264-t288*t1511+t381*t233+t1254*t1514-t934*t1089+t626*t234-t626*t134+t569*t526+t626*t254+t813*t1521+t1398*t526+t1524*t309+t825*t494+t288*t1527+t290*t1273;
+      const double t1537 = t400*vertices[4](2);
+      const double t1549 = vertices[2](0)*vertices[1](1);
+      const double t1551 = -t528*t863+t509*t513+2.0*t702*t269-t337*t167+t919*t1537-t558*t1273+t424*t1154-t557*t258+t501*t34-t885*t909+t548*t551-t424*t233-t557*t134-t424*t1+t337*t250-t1549*t70;
+      const double t1556 = vertices[0](0)*vertices[4](2);
+      const double t1557 = t1556*xi;
+      const double t1565 = t575*vertices[7](1);
+      const double t1572 = vertices[7](0)*vertices[2](1)*xi;
+      const double t1575 = -t667*t168+t557*t259-t572*t3+t1156*t326+t390*t1557-t314*t43+t424*t168+t469*t130+2.0*t292*t437-t1156*t727+t138*t1565+t791*t292-t334*t212+t334*t214-t292*t471+t734*t1572+t702*t134;
+      const double t1589 = t426*vertices[6](1);
+      const double t1598 = -t1156*t1058+t324*t582+t651*t271-t702*t234+t530*t252+t138*t781-t702*t259+t702*t258-2.0*t460*t58+t548*t567+t1589*t326-t1589*t727-2.0*t1156*t402-t626*t231+t460*t52+2.0*t1156*t513;
+      const double t1599 = t426*vertices[3](1);
+      const double t1609 = t400*vertices[4](1);
+      const double t1619 = t170*xi;
+      const double t1623 = t1599*t326-t1599*t727+2.0*t1156*t1443+t640*t233-t306*t238+t857*t212+t640*t267-t444*t909+t746*t1609-2.0*t1599*t402+2.0*t390*t1123+t390*t446+4.0*t1599*t513+t288*t819-t341*t1619-2.0*t1599*t1151;
+      const double t1633 = t557*vertices[3](1);
+      const double t1640 = t553*vertices[7](2);
+      const double t1642 = t553*vertices[4](2);
+      const double t1644 = -t640*t266-t640*t168-t334*t88-t512*t326-t530*t1511+t1254*t681-t1254*t698-t509*t315-t1633*t1130+t341*t1263-t557*t263+t740*t267+t288*t225-t314*t326+t288*t1640-t288*t1642;
+      const double t1655 = t173*xi;
+      const double t1665 = t87*vertices[7](2);
+      const double t1667 = t1633*t1089+t314*t727+t314*t402-t740*t168-t288*t150+t1141*t1042-2.0*t314*t513+t341*t280+t340*t1619-t340*t1655+t314*t1443+2.0*t557*t264-t791*t510-t557*t269-t557*t266+2.0*t1633*t1085-t304*t1665;
+      const double t1681 = t429*xi;
+      const double t1686 = t138*t289;
+      const double t1692 = -t341*t232-t337*t346+t304*t269-2.0*t1633*t950-t741*t267+t741*t168-2.0*t557*t252+t791*t1681+t768*t88+t304*t600-t740*t264+t1686*t1521-t304*t238+t337*t1242+t337*t718+t557*t1511;
+      const double t1710 = vertices[3](0)*t298;
+      const double t1711 = t1710*vertices[4](2);
+      const double t1716 = t768*t1151-2.0*t768*t513+t764*t1130-t1254*t1681-3.0*t426*t235+t557*t234-t337*t277+2.0*t702*t240+t337*t225-2.0*t1156*t1151-2.0*t422*t57+t426*t267+t295*t1711-t557*t1527+t426*t269+t651*t84;
+      const double t1724 = t288*vertices[2](1);
+      const double t1729 = t501*vertices[1](1);
+      const double t1731 = t303*vertices[2](1);
+      const double t1740 = -t424*t1273-t337*t641+2.0*t702*t266-t337*t75+t337*t1-t1724*t1130+2.0*t1724*t1085+t358*t238-t1729*t1089-2.0*t1731*t1085-t378*vertices[3](1)-t1302*t1130-t1731*t1089-t288*t35+t1724*t1089+t340*t750;
+      const double t1741 = t895*eta;
+      const double t1745 = t469*eta;
+      const double t1753 = t142*zeta;
+      const double t1760 = t517*zeta;
+      const double t1767 = -2.0*t1741*t950-t677*t233+2.0*t1745*t950-4.0*t996*t266+t677*t266-t340*t1263-t768*t90+2.0*t1753*t1681+t290*t1242-t290*t277-t290*t346-t340*t1-t1760*t961-2.0*t426*t35+2.0*t996*t267+t1760*t384;
+      const double t1787 = 2.0*t1753*t977+t1241*t167+t290*t225-t1241*t233+t303*t150-t341*t750-t857*t1130-t996*t134-t290*t641+t857*t1085+t142*t598+t424*t75+t290*t250-t996*t258+t290*t718+t857*t1089;
+      const double t1805 = t460*vertices[3](2)-t290*t167+t469*t1085-t340*t641+t996*t259-2.0*t469*t950+t306*t223-t857*t326+t626*t272+t857*t727-t651*t273+t324*t128+t509*t326+t651*t275+t324*t159-t509*t727;
+      const double t1809 = t829*zeta;
+      const double t1818 = t314*zeta;
+      const double t1824 = t501*vertices[2](1);
+      const double t1830 = -t651*t276-t934*t130+t1809*t727-t426*t243+t334*t326-t334*t727-t424*t718+2.0*t1809*t402-t501*t150+t1818*t326-2.0*t1809*t513-t424*t1242-t1818*t727-t1824*t1130-2.0*t1818*t402+2.0*t1818*t513;
+      const double t1851 = t424*t346-t548*t554+t424*t277-t424*t225+t424*t641+t517*t961-t517*t384-t303*t238-2.0*t1729*t1085+t1729*t1130+t1053*t238+t424*t167-t424*t250-2.0*t324*t88+t426*t240-2.0*t1524*t437-t1809*t326;
+      const double t1874 = t288*t250+t358*t1665+2.0*t1824*t1085+t1824*t1089-t358*t269+2.0*t441*t437+t306*t35+t340*t232-t358*t600+t288*t263+t340*t777+2.0*t771*t437+t1760*t233-t378*t83-t1760*t266-t875*vertices[4](2);
+      const double t1877 = t2*vertices[7](1);
+      const double t1878 = t1877*eta;
+      const double t1885 = vertices[4](0)*vertices[3](1);
+      const double t1893 = t380*vertices[1](1);
+      const double t1897 = t400*vertices[3](2);
+      const double t1899 = t626*t276-t530*t777+t886*t1878+t721*t1210-t396*t450*vertices[7](2)+t743*t355+t569*t378+t138*t1885-t886*t826+t396*t380*vertices[3](2)-t575*t1665+t857*t130+t575*t269+2.0*t1893*t489+t746*t523+t370*t1897;
+      const double t1921 = -t370*t432+t334*t1130+2.0*t875*t88-t875*t128+2.0*t875*t130+2.0*t1302*t1085-t498*t961-t334*t1089-t501*t249+t1184*t301+t334*t63+t892*t554+2.0*t875*t123-t560*t1655+t334*t1102-t334*t1127;
+      const double t1943 = t626*t273-t626*t271+2.0*t334*t513+t560*t232+t1053*t1665-2.0*t334*t1443-t1053*t269-t1053*t600+t920*t551-t875*t70+t443*t545-t857*t214-t530*t279+t702*t274+t726*t1058+2.0*t1321*t567-2.0*t1321*t909;
+      const double t1946 = t1877*zeta;
+      const double t1949 = t990*zeta;
+      const double t1960 = t325*vertices[4](1);
+      const double t1966 = t1122*vertices[0](1);
+      const double t1970 = xi*vertices[4](1);
+      const double t1974 = -t566*t1946+t776*t567-t572*t1949+t572*t1946-t626*t274+t885*t533-t390*t487-2.0*t1321*zeta*t567+2.0*t460*t315+t721*t1960-t726*t675+t569*t1042-t746*t314-t640*t600+2.0*t138*t1966-2.0*t138*vertices[1](0)*t1970*zeta;
+      const double t1985 = t392*vertices[3](2);
+      const double t1997 = -t460*t410-t541*t513-t443*t587+t142*t1115-t721*t349+t460*t412+2.0*t294*t722+2.0*t726*t402+t295*t1985+t640*t248-2.0*t726*t513-t626*t275+t679*t450*vertices[7](1)+t746*t846-t886*vertices[0](1)-2.0*t334*t1085;
+      const double t2000 = t1885*eta;
+      const double t2005 = t469*zeta;
+      const double t2008 = t754*eta;
+      const double t2022 = vertices[4](0)*vertices[3](2);
+      const double t2024 = t764*t326+t679*t2000-t667*t148-4.0*t708*t238+2.0*t2005*t999+2.0*t353*t2008-t569*t1143+2.0*t708*t250-t422*vertices[3](1)+t334*t582-t768*t863-t334*t1199+t443*t710+2.0*t334*t950+t390*t754-t390*t2022;
+      const double t2031 = t1321*vertices[4](2);
+      const double t2033 = vertices[7](0)*vertices[4](1);
+      const double t2035 = vertices[7](0)*t298;
+      const double t2036 = t2035*vertices[4](1);
+      const double t2039 = vertices[2](0)*vertices[0](2);
+      const double t2045 = vertices[4](0)*vertices[5](1);
+      const double t2046 = t2045*eta;
+      const double t2052 = t443*t397+t443*t1109-t337*t145*vertices[3](2)-t443*t348-t690*t355+t337*t2031-t746*t2033+t45*t2036+t530*t278+t2039*t3-2.0*t138*t1524+t741*t140-t138*t770+2.0*t2046*t489-t738*t280+t738*t1619+t138*t292;
+      const double t2074 = t358*vertices[7](1);
+      const double t2080 = -2.0*t142*t1966+t142*t726-t1012*t412+t1012*t410+t1266*t322+3.0*t142*t1225-t746*t510+t746*t858-2.0*t353*t432+t741*t344-t756*t1242-t741*t346+t142*t2074+t299*t771+t299*t1440+2.0*t726*t1151;
+      const double t2092 = t397*xi;
+      const double t2098 = -t1398*t1314-t756*t225+t756*t277+t522*t35+t557*t140+t557*t777+t738*t750-t2039*t42+t299*t797-t575*t238+t426*t237-t920*t2092+t710*t1946+t847*t619-t142*t1565+t142*t1040;
+      const double t2114 = vertices[7](0)*vertices[2](2)*xi;
+      const double t2120 = -t138*t726+t756*t641+t138*t977+t702*t271+t304*t230-t726*t326-t702*t272-t702*t273-2.0*t142*t977-t501*t259+t501*t258+t640*t499-t1322*t2114+t553*t887+t553*t2114-2.0*t830*t489;
+      const double t2130 = vertices[0](2)*vertices[6](0);
+      const double t2132 = t358*vertices[4](2);
+      const double t2141 = t738*t961-t791*t314-t738*t1263-t1686*t608-t667*t1665+t640*t280-t640*t277+t679*t815+t667*t280+t2130*t722-t390*t2132-t738*t384+t746*t770+2.0*t823*t238+t756*t167+2.0*t1302*t311;
+      const double t2145 = vertices[7](0)*vertices[3](1);
+      const double t2158 = t2022*xi;
+      const double t2163 = -t1398*t446-t791*t2145-t541*t410+t1012*t489-t679*t1256-t443*t1123+t746*t1012+t138*t1234-t756*t250+t541*t412+t756*t346-t857*t513+t710*t42-t920*t2158+3.0*t522*t238+t743*t1143;
+      const double t2175 = t295*eta;
+      const double t2180 = t597*vertices[3](1);
+      const double t2186 = -t1266*t412-2.0*t460*t311-t1322*t887+t1266*t410-2.0*t886*t991-2.0*t522*t250-t741*t269+t380*t531+2.0*t2175*t355+t667*t250+t396*t1204-t142*t2180-t710*t3-t537*t254-t299*t334-t2000*t1089;
+      const double t2193 = vertices[5](0)*vertices[0](2);
+      const double t2199 = t1710*vertices[4](1);
+      const double t2209 = t557*t272-2.0*t324*t123+t528*t412+t498*t233+t2193*t1878-t299*t1012-t498*t266+t36*t523-t299*t770-t45*t2199-t812*t1609+t501*t263-2.0*t651*t250+2.0*t651*t238-t380*t264-t530*t264;
+      const double t2213 = t2035*vertices[0](1);
+      const double t2224 = t363*vertices[0](2);
+      const double t2233 = t640*t384-t791*t770+t537*t257-t45*t2213-t640*t1619-t501*t233-t799*t1130+t812*t1180+t36*t598+3.0*t501*t266-2.0*t501*t267+t353*t2224-2.0*t1729*t489+t557*t273-2.0*t1012*t315-t45*t334-t557*t274;
+      const double t2254 = t667*t269+t791*t725-t743*t432-t142*t292+t799*t1089-t381*t277+2.0*t2000*t1199+t390*t587+t895*t437-t920*t1985-t501*t234-t875*t159+t1010*t619-t1266*t309+t443*t909-t791*t460;
+      const double t2255 = t2035*zeta;
+      const double t2258 = t672*xi;
+      const double t2273 = -t2255*t232+t2255*t1655+t885*t2258-t324*vertices[0](2)-t299*t748+t142*t460+t558*t148-t679*t408+t501*t134+t381*t1242-t378*t1878+t558*t238+t679*t510+t679*t314-t138*t608+t501*t777;
+      const double t2278 = t857*zeta;
+      const double t2283 = t392*vertices[3](1);
+      const double t2287 = t380*vertices[4](1);
+      const double t2289 = t450*vertices[4](1);
+      const double t2293 = t380*vertices[0](1);
+      const double t2298 = -t557*t14-t378*t1308-t299*t364+t2278*t326-t558*t269+t558*t1665+t710*t654-t1366*t2283-2.0*t710*t1949-t45*t2287+2.0*t45*t2289-t734*t1521+t45*t2293-t142*t1037-t640*t750+t640*t1263;
+      const double t2314 = t330*xi;
+      const double t2317 = -t640*t961+t812*t771+t36*t2074+t138*t2180-t667*t641-t667*t238-t679*t1681+t558*t641+t741*t750+t679*t770-t679*t725-t2278*t727+t639*t882-t866*t355-t708*t260-2.0*t294*t2314;
+      const double t2336 = t299*t977-t558*t280-t2193*t826+t708*t262+t537*t235+t45*t1234+t740*t269-t708*t231+t708*t261+t734*t1367+t32*t334-t522*t2031-t2193*t991+t299*t2033-t740*t140+t299*t1234;
+      const double t2349 = t924*vertices[0](2);
+      const double t2356 = t517*t266-t303*t263-t740*t344-t36*t1565+t36*t1040+t791*t1885-2.0*t2000*t1085+2.0*t799*t1085+t892*t909+t740*t346+t390*t2349+t299*t1885-t530*t1642+t530*t1640-t469*vertices[4](2)-t557*t271;
+      const double t2375 = -t679*t292+t299*t314-t685*t1207-t569*t355-t522*t261-t486*t1042+t444*t533+2.0*t348*t2314-t741*t1263-t569*t932+t569*t372+t460*t471+t886*t1308-t557*t531+t294*t330+t294*t1321;
+      const double t2385 = t450*vertices[0](1);
+      const double t2394 = t517*vertices[3](1);
+      const double t2396 = t522*t231-t522*t262-t996*t274+t740*t280+t740*t1655-t674*t727+t674*t326+t45*t1681-t32*t1234-2.0*t45*t2385-t45*t815+t306*t691+t45*t984-t741*t280-t741*t1655+t741*t1619-t45*t2394;
+      const double t2401 = t517*vertices[7](1);
+      const double t2403 = t575*vertices[4](2);
+      const double t2407 = t537*vertices[3](1);
+      const double t2418 = xi*vertices[0](1);
+      const double t2423 = t45*t2401+t390*t2403+t741*t232+t629*t1314+2.0*t2407*t1443-t677*t248+2.0*t566*t690+t886*t87+t677*t600+t422*t6+t422*t38+t746*t334+t572*t2418-t626*t84-t740*t1619-t674*t1058;
+      const double t2441 = -t299*t846-t558*t600+t679*t2145-t348*t1244+t680*t1681+t891*t576+t1189*t355-t1189*t372-t651*t237-t823*t261-2.0*t886*t127-t1366*t1521-t1366*t815+t45*t1302-t679*t748-t679*t698;
+      const double t2448 = t392*vertices[4](1);
+      const double t2455 = t358*vertices[4](1);
+      const double t2462 = 2.0*t886*t776+t32*t2287+t138*t1818+t680*t1256+t138*t2448-t680*t815-t823*t262-t1686*t1572+t2130*t349-t2130*t1960+t138*t2455-t299*t523-t746*t420-t341*t246+t747*t420-t45*t770;
+      const double t2474 = t537*vertices[6](1);
+      const double t2482 = t823*t231+t324*t70+t885*t1207-t747*t301-2.0*t348*t722-t348*t330-t2130*t1210+t348*t1044+t2130*t1244-t517*t248+t2474*t727+t1141*t2158-t2407*t326-t677*t499-t299*t1609-2.0*t886*t330;
+      const double t2486 = vertices[4](0)*vertices[7](2);
+      const double t2489 = t498*vertices[7](1);
+      const double t2505 = t680*t748-t443*t2486-t680*t1514-t45*t2489+t348*t1960+t679*t460+t2407*t727-t679*t1885-t825*t2418-t45*t681-t1266*t315-t1234*t582+2.0*t1234*t1085-t306*t2031+t396*t623-2.0*t2407*t513;
+      const double t2506 = t288*vertices[6](1);
+      const double t2519 = t431*vertices[7](1);
+      const double t2526 = t2506*t410+t996*t273-t45*t2283-t36*t2455+t299*t1180-t348*t296-2.0*t460*t437+t443*t2022+t522*t260+t996*t272-t813*t698+t813*t2519-2.0*t306*t165-t306*t225+t306*t224+t306*t230;
+      const double t2550 = t288*t759-t288*t761+2.0*t1344*t277-t290*t663-t306*t146-t1344*t242-t340*t249-t299*t858-t340*t278-2.0*t307*t505+2.0*t306*t239-t306*t248+2.0*t1344*t167-t288*t277-2.0*t426*t277-2.0*t288*t140;
+      const double t2572 = -t288*t148-t288*t167-2.0*t288*t232+t830*t412-t746*t2407+t746*t1225+t746*t1818-t337*t663-t829*t412+t829*t410+2.0*t895*t999-2.0*t895*t505-t895*t471-t528*t410+t829*t863+t829*t489-2.0*t829*t315;
+      const double t2592 = t1002*t551+t734*t608+t299*t2407+t813*t2283+t812*t2407+t36*t1524-t812*t1225-t142*t2455-t36*t1966+t36*t1225-t813*t1367-t812*t1818-t734*t420+t138*t2407-t1686*t364-t299*t1818;
+      const double t2612 = t1686*t420-t679*t380*vertices[3](1)-t142*t781-t299*t1225-t138*t1440+t2000*t1130+2.0*t378*t991-t746*t797+t746*t748+t1686*t735-t746*t977-t36*t2407+t498*t384+t651*t236-t721*t480-2.0*t825*t2314;
+      const double t2628 = vertices[7](0)*vertices[5](1)*xi;
+      const double t2634 = 2.0*t825*t480-t721*t1244+t892*t393-t2474*t326+t651*t222+t1549*t130-t138*t858+t721*t2314-2.0*t32*t799+t32*t858+t557*t168+t1366*t2628+t1366*t984-t680*t510+t679*t1514-t1069*t744;
+      const double t2649 = t1710*vertices[0](2);
+      const double t2651 = t2035*vertices[4](2);
+      const double t2660 = 2.0*t786*t1291+2.0*t786*t372-2.0*t786*t2224-t295*t332-t743*t2158-2.0*t370*t533-t768*t489+2.0*t330*eta*t545-t295*t2649-t295*t2651+t705*t545+t706*t887+t629*t446-t705*t887+t706*t2114+t705*t554-t705*t2114;
+      const double t2665 = t754*xi;
+      const double t2680 = -t1321*t887+t1321*t533-t685*t2665-t685*t1204-t651*t242+t651*t258-t469*t437+t517*t600+t1760*t248-t1760*t600+t292*t322-t292*t309-t429*t322-t429*t437+t429*t309-t537*t266;
+      const double t2702 = -t530*t917+2.0*t426*t165+2.0*t426*t225-t426*t223-2.0*t45*t2000+t45*t698-t1760*t277+t1760*t499-2.0*t886*t494-t380*t777+t486*t446+t426*t146-t340*t240+t340*t246-2.0*t504*t999+t1241*t1154;
+      const double t2725 = -2.0*t426*t148+2.0*t142*t1524-t813*t2628-t517*t499-t1524*t322+2.0*t835*t437-t380*t279+t380*t278-t835*t309-t314*t410-t509*t412-t314*t311-t314*t489-t424*t750+3.0*t426*t282+3.0*t426*t280;
+      const double t2747 = t886*t145-2.0*t426*t239-t426*t246+t426*t242+3.0*t288*t280-t522*t269+t288*t237-t288*t222-t288*t243+t1344*t222-t341*t718+t341*t641+t340*t882+t341*t240+t549*t372-2.0*t1344*t225+2.0*t32*t815;
+      const double t2756 = t440*eta;
+      const double t2776 = -t340*t531-t651*t244+t651*t243+2.0*t2756*t489+2.0*t1344*t140+2.0*t1344*t148-t340*t795-t288*t917-t825*t1878-2.0*t306*t282-t306*t280+t337*t750+2.0*t830*t315+t306*t246-t306*t245+2.0*t307*t437;
+      const double t2792 = t380*vertices[4](2);
+      const double t2798 = -t306*t236+t1184*t858-t1327*t322-t1327*t437+2.0*t607*t863-2.0*t512*t505+t396*t1237-t1327*t410-t1387*t412+t443*t1261-t353*t446-2.0*t353*t372-t353*t2792-t566*t654+2.0*t566*t1949+t569*t2158;
+      const double t2805 = t672*zeta;
+      const double t2814 = t331*vertices[1](2);
+      const double t2816 = t1393*vertices[0](2);
+      const double t2823 = t324*vertices[4](2)-2.0*t370*t1291+3.0*t370*t909-t370*t2805-t353*t1291-t1184*t420+t370*t1237+t486*t744-2.0*t32*t1681+t2255*t346+t295*t2814+t295*t2816+2.0*t370*t2224-t396*t2158+t370*t576+t486*t578;
+      const double t2831 = t380*vertices[0](2);
+      const double t2842 = -t486*t614-t486*t1223+t486*t1537-t370*t2403-t32*t977-2.0*t295*t623-t295*t2831+t295*t2792-t679*t2289-t1387*t1151-t295*t2665+t295*t398-t295*t887-t295*t567+t295*t372+t607*t489;
+      const double t2863 = -3.0*t607*t315+t607*t322-t607*t309-t607*t412+t607*t410-t898*t551+t1002*t567-t898*t567+t898*t372+2.0*t607*t437+t294*t349+t1387*t513+t528*t1151-t764*t727+t1141*t432-t1141*t1204;
+      const double t2864 = t1710*vertices[0](1);
+      const double t2884 = t45*t2864+t898*t554-t764*t1089-t764*t1085-t1234*t1130+t1234*t727-t1234*t326-t541*t326-t1012*t1443+2.0*t1012*t513-t1012*t402-t1012*t727-2.0*t45*vertices[5](0)*t495-t1002*t554-t486*t909-t891*t784;
+      const double t2903 = -t919*t981+t607*vertices[0](2)-t743*t372+2.0*t715*t1443+t486*t1291+t486*t533-t1069*t1291+t1069*t2224-t1069*t533+t1549*t727-t1549*t326+t1069*t909+t1069*t1042-t1069*t1110-t743*t526-t486*t2224;
+      const double t2909 = t295*vertices[7](0);
+      const double t2913 = t2486*eta;
+      const double t2921 = t695*vertices[3](2);
+      const double t2925 = t1549*t1089+t1549*t1085-t1387*t727+t1387*t326+t768*t402+2.0*t2909*t402+t396*t355+t353*t2913-t324*t1089-t324*t727-t486*t545+t486*t1314-t569*t1204-t569*t744+t569*t2921+t743*t932+t486*t1123;
+      const double t2930 = t597*vertices[0](2);
+      const double t2932 = t597*vertices[3](2);
+      const double t2950 = -t486*t1261-t370*t2930+t370*t2932-t528*t513+t396*t932-t370*t584-t1069*t1314-t743*t2921-t396*t526-t1549*t1130-2.0*t715*t402-t891*t2403-t919*t614-t444*t696-2.0*t391*t533-2.0*t391*t567;
+      const double t2953 = t501*vertices[0](2);
+      const double t2957 = t419*zeta;
+      const double t2961 = t2022*eta;
+      const double t2972 = t2035*vertices[0](2);
+      const double t2974 = t517*vertices[7](2);
+      const double t2976 = t685*t1985+t685*t970-t295*t2953+t295*t2158-t295*t2913-2.0*t2957*t505-t396*t432+2.0*t295*t2961-t396*t2921-2.0*t324*t1085-t607*t471+2.0*t1327*t315+t1387*t863+t370*t2132+t295*t2972-t295*t2974;
+      const double t2993 = t1122*vertices[0](2);
+      const double t2999 = 2.0*t2175*t887-2.0*t651*t240-t330*t2814-t330*t2816+t330*t446+3.0*t330*t887-t706*t545+2.0*t768*t315+t768*t412-t768*t410-t891*t578+t891*t2993-t891*t1123-t892*t887-t892*t2114+t920*t2665;
+      const double t3008 = t1556*zeta;
+      const double t3018 = t690*zeta;
+      const double t3024 = t390*vertices[7](0);
+      const double t3027 = t920*t1204-2.0*t2407*t999-2.0*t2046*t311+t443*t981-t885*t554+t885*t2114+2.0*t390*t3008-2.0*t390*t2993+2.0*t651*t246+t557*t150+t557*t1642-t557*t1640-2.0*t3018*t372-t1366*t2519+t1366*t698-t390*t1897+2.0*t3024*t311;
+      const double t3052 = -2.0*t3024*t489+2.0*t3018*t355-t690*t2224+2.0*t690*t1291-t791*t681-t138*t523-t138*t2074-t746*t1440-t138*t364+2.0*t138*t771+2.0*t142*t364-t142*t1681-2.0*t142*t420-t36*t2180-t734*t2448-t36*t771;
+      const double t3069 = -t812*t523+t142*t681+t2039*t573-t1686*t1367+t2039*t1949-t32*t847+t1686*t2448+t791*t1012+t443*t1223-t443*t1537-t443*t744+t443*t696-t390*t909+t390*t2805-t390*t393-t390*t2224;
+      const double t3088 = t498*vertices[3](2);
+      const double t3090 = -2.0*t391*t446-t443*t487-t390*t981+t1141*t526+t1141*t372+t891*t981-t685*t567+t685*t372+t685*t554-t1141*t355-t708*t275-t902*t412+2.0*t902*t863+t558*t384-t1069*t446-t295*t3088;
+      const double t3099 = t2486*xi;
+      const double t3110 = -t690*t2349-t443*t1110-t892*t2258-t892*t1207-t891*t2930+t891*t2932+t891*t2132-t891*t584+t920*t3099-t2130*t2314-t1234*t63+2.0*t1234*t130-t1234*t128-t1234*t159-t2193*t137+t1234*t88-t1012*t88;
+      const double t3136 = t569*t1142+2.0*t353*t1556+t353*t710-2.0*t353*t378+2.0*t353*t2022+t486*t754+t370*t1556+2.0*t370*t710-t370*t378+2.0*t370*t2022-t396*t1142-t295*t1556-t295*t710+t295*t378-t295*t2022-t469*t128;
+      const double t3153 = -t768*t43+t1327*t70-t138*t334+t764*t214-t764*t212-t1234*t214+t1234*t212+t295*t587-t569*t2022-t569*t348-t569*t1556+t569*t397-t486*t2022+t486*t2486-t396*t378+t396*t2022;
+      const double t3172 = t396*t348+t396*t1556-t396*t397+2.0*t607*t58-t607*t52-t1327*t58+t768*t50-t1549*t214+t1549*t212+t324*t214-t324*t212-t469*t159+t330*t378-t690*t710-t443*t754-t390*t1556;
+      const double t3190 = -t390*t710+t390*t378+t2193*t83+t512*t727+2.0*t934*t513-t426*t140-t2506*t412+t1344*t243-t440*t489-t424*t280-t517*t233+t1731*t1130+t424*t35-t424*t20-t426*t34-t424*t662;
+      const double t3209 = -t337*t35+t337*t20+t306*t34-t306*t1+t337*t662+t875*t212-t895*t130+t895*t159+t829*t43-t501*t17-t740*t563-t740*t34+t740*t467+t740*t170+t740*t17-t740*t20;
+      const double t3228 = -t740*t13-t557*t17+t740*t1+t557*t35+t557*t34-t557*t1-t776*t2022+t1012*t43-t460*t9+t460*t7+t1266*t9-t1266*t7-3.0*t690*t567-t340*t280+t341*t1655+2.0*t895*t950;
+      const double t3247 = -t934*t1085-t847*t915+t396*t1143-t396*t1042-t294*t1960-2.0*t651*t280-t440*t322+t444*t1291-t444*t1042+t444*t1110+t885*t1557-t885*t2092-t444*t2224-t885*t893+t443*t2224+t443*t1042;
+      const double t3254 = vertices[2](0)*t2;
+      const double t3255 = t3254*vertices[1](2);
+      const double t3268 = -t378*t145-t2255*t140+t378*t826-t549*t567+t866*t526-t629*t545-t690*t3255+t685*t2158-t685*t3099+t1141*t2921+t685*t2092-2.0*t2909*t1443-t294*t690-t396*t2961-t396*t2831-t396*t520+t396*t2953;
+      const double t3287 = t1119*vertices[4](2);
+      const double t3292 = -2.0*t651*t248-t2255*t344-t1141*t932+t679*t2293-t1141*t1237+t690*t372-t548*t372-t295*t1394-3.0*t32*t2289-t756*t1273-t337*t235+t337*t127*vertices[7](2)-t306*t3287-t738*t267-t738*t233-t756*t718;
+      const double t3311 = -2.0*t726*t1443+t996*t234+t667*t1273+t626*t262+2.0*t1084*t950+t1084*t1130-t740*t232-t553*t545-t460*t322-t996*t271-t337*t245-t756*t233+t530*t1527+t920*t567-t920*t372-t892*t1557;
+      const double t3314 = t3254*vertices[0](2);
+      const double t3333 = t306*vertices[5](1);
+      const double t3335 = t892*t2092-t390*t3314+t390*t3255-t390*t925-t443*t1314+t390*t2930-t390*t2932-t390*t595+2.0*t295*vertices[5](0)*t505+2.0*t2278*t505+t440*t309+t690*t3314+2.0*t651*t277+t873*t437+t873*t322-t3333*t309;
+      const double t3362 = -2.0*t651*t230+2.0*t3333*t437-2.0*t370*t578+2.0*t651*t232+2.0*t566*t1970-t566*t38-t566*t6-2.0*t370*t3008+t3333*t322-2.0*t566*t1321-2.0*t3333*t505-t294*t776-t873*t309-2.0*t651*t225+t1069*t526-t895*vertices[3](2)+t2255*t269;
+      const double t3384 = -t2255*t718+t557*t13-3.0*t370*t1123+t743*t1237+t823*t260-t444*t545-t306*t275+2.0*t370*t2993+2.0*t566*t57-t891*t3008-t337*t148+t2255*t240-t791*t1514-t2193*t494+t307*t322+t667*t230;
+      const double t3391 = t306*vertices[1](1);
+      const double t3407 = -t45*t460-t667*t663-2.0*t295*t2008-2.0*t469*t4+t3391*t309-2.0*t1729*t863-2.0*t3391*t437+t875*vertices[0](2)+t45*t1885+t45*t292+2.0*t378*t494+t348*t690+t572*t42+t886*vertices[3](1)+t710*t6+t440*vertices[3](2);
+      const double t3426 = -t566*vertices[4](1)+t566*vertices[0](1)+t710*t38-2.0*t710*t1970+t895*vertices[4](2)-t440*vertices[0](2)+t2039*t1970-t292*vertices[3](2)-t1234*vertices[4](2)-t607*vertices[3](2)+t469*vertices[3](2)+t710*vertices[4](1)+t334*vertices[4](2)+t422*vertices[4](1)-t3391*t322-t378*t87;
+      const double t3446 = t667*t368-t667*t384-t424*t14-t886*t137-t2039*t1946-t746*t1234+t886*t83+t825*t137-t422*t87-t295*t355+t295*t432-t825*t83-t746*t1885-t572*t1970+t667*t750+2.0*t3391*t505+2.0*t32*t2385;
+      const double s2 = t374+t913+t1415+t730+t415+t1644+t2254+t3292+t2120+t2950+t457+t1667+t3052+t2482+t1271+t3268+t492+t2186+t3069+t1483+t3172+t2884+t793+t2298+t2505+t1371+t535+t1692+t3247+t2462+t3090+t2317+t1026+t822+t1508+t2592+t3446+t2526+t1051+t1716+t2098+t1390+t2976+t2209+t3311+t1072+t1767+t2612+t2702+t1740+t1530+t3110+t1921+t1551+t2680+t884+t3335+t2233+t1104+t2375+t2999+t2903+t3136+t1575;
+      const double s1 = s2+t1787+t2572+t336+t1139+t603+t3362+t1805+t2273+t1899+t3027+t634+t571+t1830+t1598+t1247+t1437+t1295+t1168+t1005+t3426+t1997+t1326+t1851+t1195+t946+t2336+t1350+t3384+t766+t2423+t850+t1623+t3407+t660+t2634+t2747+t1943+t1462+t1220+t3190+t974+t2550+t1974+t1874+t2725+t2396+t2441+t2024+t2356+t2052+t693+t3153+t2080+t2660+t2141+t2163+t2776+t2798+t2823+t2842+t3209+t3228+t2863+t2925;
+      const double t3454 = 1/s1;
+      const double t3460 = vertices[0](0)*t2;
+      const double t3462 = -t710+t432+t695*t88+t533-2.0*t2665+t2961-t1897-t1393*vertices[2](2)+t587+t331*t43-t3460*vertices[2](2);
+      const double t3467 = vertices[1](0)*t2;
+      const double t3469 = -t331*vertices[3](2)-t2816+t1394-t2814+t3008+2.0*t1557-t487+t331*vertices[2](2)+t925-t924*vertices[5](2)-t3467*vertices[3](2);
+      const double t3478 = t332-t3254*vertices[4](2)+t3254*vertices[5](2)+t3460*vertices[3](2)-t2349+t3467*vertices[2](2)-t2022+2.0*t1291+t3467*vertices[4](2)-t3467*vertices[5](2)+t3314;
+      const double t3482 = -t3255+t1223-t3460*vertices[4](2)+t3460*vertices[5](2)-t2913-t2993+t1123-t1204-t567+2.0*t2158-t2224;
+      const double t3487 = t378-t393-t1556-t2831+t451+t2792+t924*vertices[4](2)-t623+t2805-2.0*t1237+t1985;
+      const double t3489 = t695*t90;
+      const double t3491 = vertices[6](0)*t2;
+      const double t3494 = -t614-2.0*t909+t372+t887+t754-t545-t2008-t3489-t1393*t43-t3491*t50+t3491*t32;
+      const double t3498 = t400*t70;
+      const double t3500 = t400*t63;
+      const double t3508 = t445*t21;
+      const double t3509 = -t3491*t45+t3491*t43-2.0*t3498+t3500-t400*t61+2.0*t400*t58+t400*t15-t400*t11+t400*t9-t400*t7-t3508;
+      const double t3511 = 2.0*t754*t21;
+      const double t3512 = t525*t21;
+      const double t3514 = t431*t4;
+      const double t3522 = t3511+t3512+t1393*t40+t3514-t1393*t4-t1393*t36-t431*t52+t1393*t52+t1393*t50-t1393*t32+t1393*t45;
+      const double t3529 = t392*t4;
+      const double t3532 = t392*t52;
+      const double t3535 = 2.0*t1122*t70;
+      const double t3536 = t1122*t61;
+      const double t3537 = t1122*t58;
+      const double t3539 = -t3460*t36+t3460*t52-t3467*t40-t3529+t3467*t4+t3467*t36+t3532-t3467*t52+t3535+t3536-2.0*t3537;
+      const double t3547 = t363*t123;
+      const double t3549 = -t331*t40+t331*t4+t331*t36-t331*t52-t331*t50+t331*t32-t331*t45-t355+t398-t3547+t3254*t123;
+      const double t3560 = 2.0*t450*t70;
+      const double t3561 = t450*t63;
+      const double t3562 = t450*t130;
+      const double t3564 = -t3254*t121+t3254*t119+t363*t159-t3254*t159-t3254*t90+t3254*t142+t3254*t88-t3254*t138-t3560+t3561+2.0*t3562;
+      const double t3565 = t450*t128;
+      const double t3576 = -t3565-t924*t123+t924*t121+t3467*t159-t924*t119+t924*t159+t924*t90-t924*t142-t924*t88+t924*t138+t3491*t90;
+      const double t3582 = t380*t70;
+      const double t3584 = t380*t63;
+      const double t3592 = -t3491*t142-t3491*t88+t3491*t138+2.0*t3582-t3584-2.0*t380*t130+t380*t128-t380*t15+t380*t11+t380*t214-t380*t212;
+      const double t3594 = 2.0*t1556*t76;
+      const double t3595 = t354*t76;
+      const double t3596 = t525*t76;
+      const double t3597 = t397*t76;
+      const double t3599 = t363*t90;
+      const double t3600 = t363*t88;
+      const double t3601 = t587*t76;
+      const double t3603 = t371*t76;
+      const double t3608 = -t3594+t3595-t3596+2.0*t3597+t3599-t3600+2.0*t3601-t3603+t931*t76-2.0*t672*t76+t3460*t123;
+      const double t3612 = t392*t123;
+      const double t3616 = t392*t159;
+      const double t3617 = t2022*t21;
+      const double t3619 = t544*t21;
+      const double t3623 = -t3460*t121-t3460*t159+t3612-t3467*t123+t3467*t121-t3467*t119-t3616-2.0*t3617+t3619-t1313*t21+2.0*t2486*t21;
+      const double t3624 = t431*t50;
+      const double t3625 = t431*t43;
+      const double t3626 = t695*t50;
+      const double t3628 = t397*t21;
+      const double t3632 = t1122*t63;
+      const double t3635 = -t3624+t3625+t3626-t695*t43-2.0*t3628+t3460*t40-t3460*t4-t3632+t3460*t119+t446+t1393*vertices[3](2);
+      const double t3641 = t460*xi;
+      const double t3643 = t334*xi;
+      const double t3647 = -t770+t698-t1440-t2000+2.0*t3641-t408+2.0*t3643+t799-t858-t1393*vertices[3](1)+t1393*vertices[2](1);
+      const double t3658 = -t1393*vertices[1](1)+t1393*vertices[0](1)+t331*vertices[3](1)-t331*vertices[2](1)+t331*vertices[1](1)-t331*vertices[0](1)+t3467*vertices[3](1)-t3467*vertices[2](1)-t3460*vertices[3](1)+t3460*vertices[2](1)-t1524;
+      const double t3670 = t924*vertices[5](1)-t924*vertices[4](1)-t924*vertices[1](1)+t924*vertices[0](1)-t3254*vertices[5](1)+t3254*vertices[4](1)+t3254*vertices[1](1)-t3254*vertices[0](1)+t3467*vertices[5](1)-t3467*vertices[4](1)-t1225;
+      const double t3675 = t1234*xi;
+      const double t3677 = t1966+t847-2.0*t1885*xi-t2287-t2385-t726-t815+2.0*t770*xi+t771+t984-2.0*t3675;
+      const double t3680 = t292*xi;
+      const double t3684 = -t364+t977+t2448+t1681-2.0*t3680+t1818+t3460*vertices[4](1)+t420+t2289-t3460*vertices[5](1)-t608;
+      const double t3685 = vertices[6](1)*zeta;
+      const double t3687 = vertices[5](1)*zeta;
+      const double t3693 = t392*t57;
+      const double t3694 = t2293+t1234+t1037-t681-t3460*t3685+t3460*t3687-t3460*t57+t3460*t6-t3467*t3687+t3467*t57-t3693;
+      const double t3698 = t392*t6;
+      const double t3699 = t695*t776;
+      const double t3700 = t431*t330;
+      const double t3701 = t431*t776;
+      const double t3705 = t3467*t3685-t3467*t6+t3698-t3699-t3700+t3701-t460-t334+t695*t330+t431*t145+t1393*t891;
+      const double t3707 = t431*t127;
+      const double t3708 = vertices[2](1)*eta;
+      const double t3716 = t1393*t127-t3707-t1393*t3708+t292+t1885+t1393*t330-t1393*t295+t1393*t353-t1393*t776-t1393*t145+t3491*t295;
+      const double t3725 = t400*t104;
+      const double t3726 = t400*t2418;
+      const double t3732 = t1885*t21;
+      const double t3734 = t419*t21;
+      const double t3735 = -t3491*t353+t3491*t776-2.0*t400*t494+t400*t87-t3725+2.0*t3726-t3491*t330-2.0*t846*t21+t300*t21+2.0*t3732-t3734;
+      const double t3736 = t314*t21;
+      const double t3738 = t509*t21;
+      const double t3740 = 2.0*t334*t21;
+      const double t3741 = t857*t21;
+      const double t3748 = 2.0*t3736-t3738-t3740+t3741+t400*t83-t400*t137-t2283+t400*t18-t400*t98+t3460*t127-t3460*t3708;
+      const double t3751 = t392*t127;
+      const double t3756 = 2.0*t1122*t2418;
+      const double t3758 = t392*t145;
+      const double t3762 = -t3467*t127+t3751+t3467*t3708-t3460*t145+t3460*t891-t3756+t3467*t145-t3758-t3467*t891-t331*t127+t331*t3708;
+      const double t3763 = t1122*t494;
+      const double t3765 = t1122*t87;
+      const double t3766 = t1122*t104;
+      const double t3767 = t363*t57;
+      const double t3775 = 2.0*t3763-t3765+t3766+t3767-t331*t330+t331*t295-t331*t353+t331*t776+t331*t145-t331*t891-t3254*t3685;
+      const double t3780 = t450*t104;
+      const double t3782 = 2.0*t450*t2418;
+      const double t3790 = t3254*t3687-t3254*t57-t3780+t3782+t3254*t390-t3254*t690-t3254*t370+t3254*t1321+t3254*t6-t363*t6+t924*t3685;
+      const double t3793 = t450*t38;
+      const double t3794 = t450*t1970;
+      const double t3803 = -t924*t3687+t924*t57+t3793-2.0*t3794+t3491*t690+t3491*t370-t3491*t1321-t924*t390+t924*t690+t924*t370-t924*t1321;
+      const double t3808 = t380*t104;
+      const double t3809 = t380*t2418;
+      const double t3815 = t314*t76;
+      const double t3817 = t509*t76;
+      const double t3818 = t429*t76;
+      const double t3819 = -t924*t6+2.0*t380*t1970+t3808-2.0*t3809-t3491*t390-t380*t18+t380*t98-t380*t38-2.0*t3815+t3817-t3818;
+      const double t3821 = 2.0*t292*t76;
+      const double t3824 = t814*t76;
+      const double t3825 = t770*t76;
+      const double t3827 = t363*t690;
+      const double t3828 = t363*t1321;
+      const double t3830 = t695*t1321;
+      const double t3834 = t3821+t380*t3-t380*t42+t3824-2.0*t3825+t3827-t3828-t1255*t76+t3830+2.0*t725*t76-t695*t690;
+      const double t3840 = t166*eta;
+      const double t3841 = t265*zeta;
+      const double t3842 = t390*vertices[0](2);
+      const double t3843 = vertices[1](1)*vertices[2](2);
+      const double t3848 = vertices[3](1)*vertices[2](2);
+      const double t3852 = vertices[1](1)*vertices[0](2);
+      const double t3853 = t3852*eta;
+      const double t3855 = -t3840-t3841+t3842-t3843*xi-t295*vertices[3](2)+t145*vertices[1](2)+t81*eta+t3848*zeta-t443*vertices[7](2)+t87*vertices[1](2)-2.0*t3853;
+      const double t3857 = t690*vertices[1](2);
+      const double t3858 = t353*vertices[3](2);
+      const double t3863 = t443*vertices[4](2)-t1145-t3857+t3858+t1119*vertices[1](2)+t1284-t1119*vertices[5](2)+t3287+t898*vertices[5](2)+t1106-t548*vertices[5](2);
+      const double t3867 = vertices[0](1)*vertices[1](2);
+      const double t3868 = t3867*zeta;
+      const double t3871 = t29*zeta;
+      const double t3874 = t3867*eta;
+      const double t3877 = t548*vertices[1](2)+t1105*vertices[5](2)-t899+t3868+t1091+t486*vertices[7](2)-t486*vertices[4](2)-t3871-2.0*t265*eta+2.0*t3874+t443*vertices[3](2);
+      const double t3884 = -t898*vertices[1](2)-t1120+t17-t22-t1105*vertices[1](2)-t486*vertices[3](2)-t443*vertices[0](2)+t26+t28-2.0*t30+t898*t119;
+      const double t3887 = t298*vertices[0](2);
+      const double t3894 = vertices[1](1)*vertices[3](2);
+      const double t3897 = -t87*t3887+t87*t299+t87*t138+t265-2.0*t87*t142-t34+t898*t61-t3894+t3852+t898*t436-t898*t470;
+      const double t3904 = t353*vertices[0](2);
+      const double t3907 = vertices[1](1)*vertices[6](2);
+      const double t3909 = t390*t50;
+      const double t3910 = -t898*t58+t443*t61-t443*t43-t919*t159+t39+t919*t123+t919*t43-t3904+2.0*t3843*t21-t3907*t21-t3909;
+      const double t3913 = t891*t50;
+      const double t3914 = t390*t43;
+      const double t3915 = t295*vertices[0](2);
+      const double t3919 = t298*vertices[4](2);
+      const double t3921 = t298*vertices[7](2);
+      const double t3923 = t298*vertices[3](2);
+      const double t3926 = -t891*t43+t3913+t3914+t3915+t898*t32-t898*t121-t898*t45-t295*t3919+t295*t3921-t295*t3923-t548*t61;
+      const double t3934 = -t89+2.0*t91-t548*t436-t1276+t548*t470-t97+t548*t58-t390*t61-t919*t50+t105+t443*t159;
+      const double t3946 = 2.0*t353*t90;
+      const double t3947 = t353*t52;
+      const double t3948 = t353*t88;
+      const double t3950 = -t443*t123-2.0*t107+t443*t50+t443*t436-t443*t470-t443*t58+t95*t142+t3946+t3947-t3948-t390*vertices[3](2);
+      const double t3951 = t353*t4;
+      const double t3961 = -2.0*t3951-t129+t486*t58-t486*t61+t486*vertices[0](2)+t131-t486*t50-t486*t436+t486*t470+t486*t43+2.0*t133;
+      const double t3965 = t295*t88;
+      const double t3968 = t295*t90;
+      const double t3974 = t295*t3887-t295*t52+t3965+2.0*t295*t4-2.0*t3968-t136-t486*t159-t140+t486*t123-t1105*t128+t1105*t130;
+      const double t3975 = vertices[1](1)*vertices[4](2);
+      const double t3976 = t3975*eta;
+      const double t3978 = vertices[1](1)*vertices[7](2);
+      const double t3980 = eta*zeta;
+      const double t3981 = t25*t3980;
+      const double t3982 = t166*t3980;
+      const double t3983 = t29*t3980;
+      const double t3986 = t81*t3980;
+      const double t3989 = t265*t3980;
+      const double t3992 = t3976-t1105*t70-t3978*eta-t3981+t3982+2.0*t3983+t79*t3980-t3986-2.0*t3848*t3980+2.0*t3989+2.0*t165;
+      const double t4003 = t145*t32;
+      const double t4004 = t95*t3887+t95*t746-t95*t3919+t1105*t119-t1105*t121-t1105*t45+t145*t45+t1105*t32-t4003-t175+t178;
+      const double t4007 = 2.0*t3867*t3980;
+      const double t4008 = t690*t32;
+      const double t4010 = t690*t45;
+      const double t4014 = t1105*t63+t203-t4007-t221+t4008+t548*t45-t4010-t548*t32-t548*t119-t224+t548*t121;
+      const double t4026 = -t95*t299+t87*t3919+t1119*t45-t1119*t32+t1119*t121-t1119*t119+t494*t746-t494*t3919-t494*t299+t494*t3887-t3867;
+      const double t4031 = -t87*t746+2.0*t3894*eta-t235-2.0*t239+t240+t245-t246+t248-t266+t267+t282;
+      const double t4043 = t306*vertices[0](2);
+      const double t4044 = vertices[3](0)*xi;
+      const double t4046 = -t363*t746-t1710*t32-t2651+t2035*vertices[5](2)-t306*vertices[3](2)+t1710*vertices[1](2)-t517*vertices[1](2)+t4043+t1096+t1711+t4044*t3887;
+      const double t4047 = t445*zeta;
+      const double t4050 = t557*vertices[0](2);
+      const double t4051 = t354*eta;
+      const double t4054 = t566*zeta;
+      const double t4057 = t1338-t4047+t1710*t121-t1710*t119+t4050-t4051+t498*vertices[1](2)+t363*vertices[1](2)-t4054+t371*eta+t517*vertices[5](2);
+      const double t4059 = t501*vertices[1](2);
+      const double t4067 = -t4059+t380*vertices[1](2)+t518+t340*vertices[0](2)-t340*vertices[3](2)-t340*vertices[4](2)+t340*vertices[7](2)-t3088+t986-t740*vertices[0](2)+t740*vertices[3](2);
+      const double t4070 = vertices[1](0)*vertices[2](2);
+      const double t4072 = vertices[1](0)*vertices[3](2);
+      const double t4075 = vertices[1](0)*vertices[4](2);
+      const double t4076 = t4075*eta;
+      const double t4077 = vertices[1](0)*vertices[7](2);
+      const double t4079 = t426*vertices[0](2);
+      const double t4080 = t426*vertices[3](2);
+      const double t4083 = t740*vertices[4](2)-t740*vertices[7](2)-t4070*xi+2.0*t4072*eta+t4076-t4077*eta-t4079+t4080-t498*vertices[5](2)+t2972-t2035*vertices[1](2);
+      const double t4087 = t501*t32;
+      const double t4093 = t501*t45;
+      const double t4094 = t380*t32;
+      const double t4097 = t4044*t746+t4087-t4044*t299-t4044*t3919-t695*t299-t695*t3919-t498*t32-t4093-t4094+t2035*t32-t498*t119;
+      const double t4109 = t695*t3887+t695*t746+t517*t61-t517*t58+t380*t45-t2035*t45+t340*t123-t340*t159-t340*t50+t340*t43-t340*t436;
+      const double t4114 = t426*t88;
+      const double t4115 = t426*t52;
+      const double t4116 = t426*t4;
+      const double t4119 = 2.0*t426*t90;
+      const double t4122 = t340*t58+t340*t470-t340*t61-t710-t4114+t4115-2.0*t4116+t4119-t517*t470+t517*t436-t4072;
+      const double t4131 = t306*t88;
+      const double t4132 = t498*t470-t498*t436-t498*t61+t498*t58-t306*t3919+t306*t3921-t422+t306*t3887-t306*t3923-t2665+t4131;
+      const double t4139 = t306*t90;
+      const double t4147 = -t306*t52+t498*t45+t498*t121+t566-2.0*t4139+2.0*t306*t4+t2961-t639*t159+t740*t159-t639*t50+t639*t43;
+      const double t4159 = t639*t123-t740*t43-t740*t123-t740*t470+t740*t436+t740*t50-t557*t61-t740*t58+t740*t61-t363*t3887+t363*t299;
+      const double t4162 = vertices[1](0)*vertices[0](2);
+      const double t4163 = t4162*eta;
+      const double t4168 = t363*t3919-2.0*t4163-t557*vertices[3](2)+t1710*t45+t4162+t1291-t567-t2224-t2831+2.0*t451-t623;
+      const double t4171 = t422*eta;
+      const double t4175 = t371*t3980;
+      const double t4179 = t566*t3980;
+      const double t4181 = t1985-t2974-t1710*vertices[5](2)+t754+t695*t142+2.0*t4171-2.0*t566*eta-t4175-2.0*t2008-2.0*t1095*t3980+2.0*t4179;
+      const double t4191 = 2.0*t422*t3980;
+      const double t4193 = t2035*t119-t2035*t121+t931*t3980+t2035*t130-t3489+t2035*t63-t2035*t70-t4191-2.0*t3508+t3511+t3512;
+      const double t4197 = t3514-2.0*t3529+t3532-t2035*t128+t398-t3560+2.0*t3561+t3562-t3565+t3582-t3584;
+      const double t4202 = t525*t3980;
+      const double t4203 = t354*t3980;
+      const double t4204 = t445*t3980;
+      const double t4206 = t530*t50;
+      const double t4207 = 2.0*t3599-t3600-t3617+t3619-t3628+2.0*t4070*t21-t4202+t446+t4203+2.0*t4204+t4206;
+      const double t4208 = t557*t43;
+      const double t4209 = t557*t50;
+      const double t4210 = vertices[1](0)*vertices[6](2);
+      const double t4220 = t4208-t4209-t4210*t21+t363*t138-2.0*t363*t142+t517*t119-t517*t121-t517*t45-t2649+t517*t32-t530*t43;
+      const double t4228 = -t2000-t408+t3643+2.0*t799-t858-2.0*t2385+t984-t3675+t977+t2289+t2293;
+      const double t4236 = t1234-t2756-2.0*t1378+t740*vertices[7](1)-t740*vertices[4](1)-t740*vertices[3](1)+t740*vertices[0](1)-t2489+t1431-t340*vertices[7](1)+t340*vertices[4](1);
+      const double t4244 = t340*vertices[3](1)+t1633+t1421-t2035*vertices[5](1)+t498*vertices[5](1)-t307+2.0*t1741+t2036+t517*vertices[1](1)-t814*eta-t715;
+      const double t4247 = t646-t363*vertices[1](1)+t949+t2278-t2005-t1599+t504+t830-t1893+t1710*vertices[5](1)-t334;
+      const double t4259 = -t3707+t469-t740*t776+t740*t95-t740*t990-t740*t87+t740*t494+t498*t990+t557*t87-t498*t95-t306*t1105;
+      const double t4265 = t426*t690;
+      const double t4266 = t426*t145;
+      const double t4268 = t306*t690;
+      const double t4269 = -t498*t494+t875-t340*t494+t498*t87-t1710*vertices[1](1)+t340*t87+t4265-t4266-t895+t306*t548-t4268;
+      const double t4272 = t306*t1321;
+      const double t4282 = t306*t145+2.0*t4272-2.0*t306*t127-t2199-t340*t57+t340*t6+t340*t990-t340*t330+t340*t776+t1729-t639*t330;
+      const double t4294 = -t639*t57-t498*vertices[1](1)-t740*t6+t639*t776+t740*t330+t740*t57+t2035*vertices[1](1)+t2035*t2418-t2035*t104+t528*t21-t2035*t3685;
+      const double t4302 = t557*t330;
+      const double t4303 = t530*t776;
+      const double t4306 = t557*t776;
+      const double t4307 = -2.0*t934*t21+t530*t330-t517*t353-t4302-t4303-t340*vertices[0](1)+t3732-t3734-t1710*t295+t4306+t3736;
+      const double t4317 = -t3738+t363*t443+t1710*t353-t3740+2.0*t3741-t363*t486-t363*t548-t2283-t306*t898+t306*t1119+2.0*t363*t370;
+      const double t4324 = t501*t295;
+      const double t4327 = t380*t353;
+      const double t4329 = -t363*t390-t2035*t353-t380*t295+t498*t3685-t4044*t443+t4324-t498*t295-t498*t3687+t2864+t4327+t498*t353;
+      const double t4330 = t501*t353;
+      const double t4337 = t814*t3980;
+      const double t4338 = t324*t3980;
+      const double t4340 = t857*t3980;
+      const double t4342 = t429*t3980;
+      const double t4343 = t509*t3980;
+      const double t4344 = -t4330-t695*t898+t695*t486-t1255*t3980-t695*t370+2.0*t714*t3980+t4337-2.0*t4338-2.0*t4340-t4342+t4343;
+      const double t4348 = 2.0*t469*t3980;
+      const double t4358 = t4348-t2035*t1970+t2035*t38+t517*t295+t517*t3687+t4044*t486+t4044*t548+t1710*t3685-t4044*t898+t2401-t1710*t3687;
+      const double t4364 = t426*t127;
+      const double t4368 = 2.0*t426*t1321;
+      const double t4369 = -t324+t2035*t295+t2035*t3687+2.0*t3751-2.0*t1745-t2394-t517*t3685+2.0*t4364+t517*t95-t4368-t3758;
+      const double t4378 = -t517*t990-t517*t87+t517*t494+2.0*t324*eta-2.0*t3780+t3782+t3793-t3794+t3808-t3809+t363*t898;
+      const double t4386 = t3827-2.0*t3828+t639*t6-t340*t95+t3830+t695*t548-t695*t443-t1084-t2213+t934*xi-t517*vertices[5](1);
+      const double t4394 = t3840+t3841-t3842+t3853+t3857-t3858-2.0*t3868+t3871-t3874+t758*vertices[2](2)-t761;
+      const double t4400 = vertices[4](1)*vertices[5](2);
+      const double t4406 = -t917+t818*vertices[1](2)-t818*vertices[2](2)+t819+2.0*t229*zeta-t177*zeta-t4400*eta+t390*vertices[4](2)-t38*vertices[1](2)-t6*vertices[1](2)+t553*vertices[1](2);
+      const double t4417 = -t553*vertices[2](2)-t705*vertices[1](2)+t705*vertices[2](2)-t1642+t1640+t569*vertices[4](2)-t569*vertices[7](2)+t396*vertices[0](2)-t396*vertices[3](2)-t396*vertices[4](2)+t396*vertices[7](2);
+      const double t4422 = vertices[1](1)*vertices[5](2);
+      const double t4426 = t1527-t1511+t295*vertices[4](2)-2.0*t3975*zeta+t396*t88+t14-t3852-t35+t4422*xi+2.0*t3904+2.0*t3909;
+      const double t4431 = -t59+t3978*zeta+t62-2.0*t64-t3913-t3914-t3915+t69-t71-t82+t85;
+      const double t4434 = t111-t3946-t3947+2.0*t3948+t3951-t3965+t3968-t148-t3976-t569*vertices[0](2)+t3981;
+      const double t4439 = -2.0*t3982-t3983+t3986-t3989+t553*t130-t167+t4003+t180-t186-t188+2.0*t192;
+      const double t4446 = t200+t201-2.0*t202+t205-t207+2.0*t208-t210+t4007-2.0*t4008-2.0*t4422*t76+t3907*t76;
+      const double t4450 = t289*vertices[4](2);
+      const double t4460 = t4010-t891*t4450+t891*t123-t553*t142+t225+t553*t138-t553*t36+t553*t40-t705*t470-t705*t130+t705*t128;
+      const double t4462 = t289*vertices[0](2);
+      const double t4467 = t289*vertices[3](2);
+      const double t4470 = t289*vertices[7](2);
+      const double t4475 = t230+t390*t159-t390*t4462-2.0*t390*t123+t891*t4462-t891*t4467+t390*t4450-t390*t4470+t891*t4470+t390*t4467-t396*t436;
+      const double t4486 = t396*t130-t396*t128+t295*t128+t396*t470-t396*t52+t3867+t705*t436-t553*t128-t553*t436+t553*t470+t3975;
+      const double t4498 = -t569*t470+t569*t436+t569*vertices[3](2)+t569*t128-t569*t130-t370*t4450+t370*t4470+t370*t4462-t370*t4467-t396*t90+t396*t4;
+      const double t4512 = t818*t70-t818*t63-t6*t138+t818*t138-t818*t36-t238+2.0*t4400*t3980-t173*t3980+t38*t4462-t38*t791-t818*t142;
+      const double t4525 = t818*t40-t95*t679+t95*t4467-t818*t58+t95*t791+t818*t61-t1970*t4462+t758*t36-t758*vertices[1](2)+2.0*t38*t32+t1970*t791;
+      const double t4537 = -t1970*t679-t95*t4462-t38*t45+t1970*t4467+t38*t679-t38*t4467-t229+t705*t36-t95*t32-t705*t138+t705*t142;
+      const double t4544 = -t705*t40+t759-t758*t138+t758*t142-t758*t40-t249+t250+2.0*t252-t264+t278-2.0*t279;
+      const double t4553 = -t4043-2.0*t1338+t4047-t4050+t4051+t4054+t4059-t4076+2.0*t4079-t4080-2.0*t4087;
+      const double t4562 = -t557*t4462+t557*t4467+t557*t4450-t557*t4470+t4093+t584-t424*vertices[0](2)+t4094+t424*vertices[3](2)+t424*vertices[4](2)+t337*vertices[0](2);
+      const double t4570 = -t337*vertices[3](2)-t337*vertices[4](2)+t337*vertices[7](2)+t2403-t576+t2930-t597*vertices[1](2)+t597*vertices[2](2)-t2932-t595+t594*vertices[1](2);
+      const double t4574 = vertices[1](0)*vertices[5](2);
+      const double t4583 = -t594*vertices[2](2)+t784-2.0*t4075*zeta+t4574*xi+t358*vertices[1](2)-t358*vertices[2](2)-t575*vertices[1](2)-t2132-2.0*t4574*t76+t4210*t76+t530*t123;
+      const double t4593 = -t358*t142+t358*t40+t432+t530*t4462-t530*t4467-t530*t4450+t530*t4470+2.0*t4114-t4115+t4116-t4119;
+      const double t4599 = vertices[4](0)*vertices[5](2);
+      const double t4606 = vertices[4](0)*xi;
+      const double t4608 = -t431*vertices[1](2)-t400*vertices[1](2)+2.0*t886*zeta-t544*zeta-t4599*eta+t575*vertices[2](2)+2.0*t431*t32-t431*t45+t422+t597*t36-t4606*t4462;
+      const double t4619 = t4606*t791-t4606*t679-t4131+t4139+t358*t138-t358*t36+t597*t142-t597*t40-t597*t138+t695*t4467-t594*t142;
+      const double t4632 = t594*t40-t431*t4467-t695*t4462+t695*t791-t695*t679-t431*t791+t431*t679+t431*t4462-t594*t58+2.0*t4599*t3980-t1313*t3980;
+      const double t4644 = -t695*t32+t594*t70-t594*t63+t594*t61-t400*t138+t594*t138-t594*t36+t4163+2.0*t3008+t1557-t487;
+      const double t4650 = t4606*t4467-t4162+t1223-2.0*t2993+t1123+t378-t393-t1556+t337*t470-t337*t436-t337*t90;
+      const double t4660 = t337*t4+t4077*zeta-t424*vertices[7](2)-t1237-t614+t887+t306*vertices[4](2)+t337*t88-t337*t52-t575*t130+t575*t128;
+      const double t4670 = t557*vertices[4](2)-t4171-t575*t470+t575*t436-2.0*t557*t123+t557*t159+t4175-t4179+t424*t128+t288*t4470+t337*t130;
+      const double t4682 = t306*t128-t337*t128-t886-t424*t130+t358*t130+t4191-t358*t436-t424*t470+t424*t436+t288*t4462-t288*t4450;
+      const double t4686 = -t3498+t3500+t3535+t3536-t3537-t358*t128+t358*t470-t355-t3547-t3594+2.0*t3595;
+      const double t4692 = -t3596+t3597+t3601-t3603+2.0*t3612-t3616-2.0*t3624+t3625+t3626-t288*t4467-2.0*t3632;
+      const double t4699 = -t575*t40-t575*t138+t575*t36+t575*t142+t4202-2.0*t4203-t4204-t4206-t4208+2.0*t4209+t4075;
+      const double t4707 = -t1440+t3641-2.0*t1524-t1225+2.0*t1966+t771+t2448+t1681-t3680+t1818-t608;
+      const double t4711 = -t681+t2756+t307-t1741-t646-t949-t2278+2.0*t2005+t1599-2.0*t504-2.0*t3693;
+      const double t4716 = t3698+t401+t431*vertices[1](1)+t2046+t2957-t1115+t594*vertices[2](1)-t3699-t3700-t594*vertices[1](1)+t781;
+      const double t4725 = t2180-t597*vertices[2](1)+t597*vertices[1](1)-t319-t873*xi+2.0*t441+t1565+t358*vertices[2](1)+2.0*t3701-t337*vertices[7](1)+t337*vertices[4](1);
+      const double t4737 = t337*vertices[3](1)-t337*vertices[0](1)+t424*vertices[7](1)-t424*vertices[4](1)-t424*vertices[3](1)-t2074+t2455-t575*vertices[2](1)-t460+2.0*t873*t76-t528*t76;
+      const double t4742 = -t530*t57+t358*t370-t358*t3708+t292-t469-2.0*t4265+t4266+t895+t4268-t4272-t1729;
+      const double t4747 = -t3725+t3726-t1040+t4302+t4303-2.0*t4306-t358*t1970-t4324-t4327+2.0*t4330-t4337;
+      const double t4755 = t4338-t937+t4340+2.0*t4342-t4343-t4348+2.0*t557*t57-t557*t6+t557*t553-t557*t705-t557*t758;
+      const double t4768 = -t1809-t530*t553+t530*t705+t530*t758-t530*t818+t358*t38-t358*t95+t358*t990+t424*vertices[0](1)+t1745-t337*t690;
+      const double t4780 = t337*t145+t575*t1970+t424*t1970-t424*t38-t337*t95+t337*t1321-t337*t127+t337*t990-t575*t990-t337*t1970-t306*t38;
+      const double t4791 = t337*t38+t557*t818-t575*t38+t575*t95-t3756-t4606*t705-2.0*t431*t353+t431*t295-t431*t553-t4364+t4368;
+      const double t4805 = -2.0*t2045*t3980+t300*t3980+t695*t353+t288*t705+t288*t758-t288*t818-2.0*t607*zeta+t424*t95-t424*t990-t288*t553-t594*t3708;
+      const double t4816 = t400*t390-t594*t390+t594*t891+t695*t396-t695*t705+t594*t370+t607+t3763-t3765+t431*t569+t431*t705;
+      const double t4827 = t695*t553-t431*t396+2.0*t3766+t3767+t594*t494-t575*t370+t575*t3708-t594*t2418+t594*t104-t594*t87+t597*t390;
+      const double t4838 = -t358*t390+t358*t891-t597*t891+t575*t390-t575*t891-t597*t370-t440+t575*vertices[1](1)+t597*t3708-t598-t695*t569;
+      const double t4844 = t4606*t553-t4606*t569+t4606*t396-t3815+t3817-2.0*t3818+t3821+t3824-t3825-t358*vertices[1](1)+t1084;
+      jacobians[point][0][0] = -(t24+t47+t68+t92+t109+t125+t147+t161+t183+t195+t211+t226+t241+t255+t270+t283)*t3454;
+      jacobians[point][0][1] = (t3462+t3469+t3478+t3482+t3487+t3494+t3509+t3522+t3539+t3549+t3564+t3576+t3592+t3608+t3623+t3635)*t3454;
+      jacobians[point][0][2] = (t3647+t3658+t3670+t3677+t3684+t3694+t3705+t3716+t3735+t3748+t3762+t3775+t3790+t3803+t3819+t3834)*t3454;
+      jacobians[point][1][0] = (t3855+t3863+t3877+t3884+t3897+t3910+t3926+t3934+t3950+t3961+t3974+t3992+t4004+t4014+t4026+t4031)*t3454;
+      jacobians[point][1][1] = -(t4046+t4057+t4067+t4083+t4097+t4109+t4122+t4132+t4147+t4159+t4168+t4181+t4193+t4197+t4207+t4220)*t3454;
+      jacobians[point][1][2] = -(t4228+t4236+t4244+t4247+t4259+t4269+t4282+t4294+t4307+t4317+t4329+t4344+t4358+t4369+t4378+t4386)*t3454;
+      jacobians[point][2][0] = (t4394+t4406+t4417+t4426+t4431+t4434+t4439+t4446+t4460+t4475+t4486+t4498+t4512+t4525+t4537+t4544)*t3454;
+      jacobians[point][2][1] = -(t4553+t4562+t4570+t4583+t4593+t4608+t4619+t4632+t4644+t4650+t4660+t4670+t4682+t4686+t4692+t4699)*t3454;
+      jacobians[point][2][2] = -(t4707+t4711+t4716+t4725+t4737+t4742+t4747+t4755+t4768+t4780+t4791+t4805+t4816+t4827+t4838+t4844)*t3454;
+    };
+};
+
+
+
+template <>
+void FELinearMapping<3>::compute_jacobian_gradients (const DoFHandler<3>::cell_iterator &cell,
+                                                    const vector<Point<3> > &unit_points,
+                                                    vector<Tensor<3,3> >    &jacobians_grad) 
+{
+  Assert (unit_points.size() == jacobians_grad.size(),
+         ExcWrongFieldDimension(jacobians_grad.size(), unit_points.size()));
+
+  const unsigned int dim = 3;
+  
+  Point<dim> vertices[GeometryInfo<dim>::vertices_per_cell];
+  for (unsigned int l=0; l<GeometryInfo<dim>::vertices_per_cell; ++l)
+    vertices[l] = cell->vertex(l);
+
+         for (unsigned int point=0; point<unit_points.size(); ++point)
+           {
+             const double xi  = unit_points[point](0);
+             const double eta = unit_points[point](1);
+             const double zeta= unit_points[point](2);
+
+              const double t1 = vertices[4](1)*vertices[1](2);
+              const double t2 = t1*zeta;
+              const double t3 = vertices[4](1)*vertices[2](2);
+              const double t4 = t3*zeta;
+              const double t5 = vertices[5](1)*xi;
+              const double t6 = t5*vertices[1](2);
+              const double t7 = 2.0*t6;
+              const double t8 = vertices[7](1)*zeta;
+              const double t9 = t8*vertices[1](2);
+              const double t10 = vertices[4](1)*vertices[0](2);
+              const double t11 = t10*xi;
+              const double t12 = 2.0*t11;
+              const double t13 = t5*vertices[3](2);
+              const double t15 = vertices[2](1)*xi;
+              const double t16 = t15*vertices[0](2);
+              const double t17 = 2.0*t16;
+              const double t18 = vertices[2](1)*zeta;
+              const double t19 = t18*vertices[4](2);
+              const double t20 = vertices[1](1)*vertices[4](2);
+              const double t21 = t20*zeta;
+              const double t22 = vertices[1](1)*vertices[5](2);
+              const double t23 = t22*xi;
+              const double t24 = 2.0*t23;
+              const double t25 = vertices[0](1)*vertices[4](2);
+              const double t26 = t25*zeta;
+              const double t27 = 2.0*t26;
+              const double t28 = vertices[1](1)*vertices[7](2);
+              const double t29 = t28*zeta;
+              const double t30 = vertices[4](1)*zeta;
+              const double t31 = t30*vertices[3](2);
+              const double t32 = 2.0*t31;
+              const double t33 = vertices[5](1)*zeta;
+              const double t34 = t33*vertices[0](2);
+              const double t35 = vertices[0](1)*vertices[7](2);
+              const double t36 = t35*zeta;
+              const double t37 = 2.0*t36;
+              const double t38 = t1*xi;
+              const double t39 = 2.0*t38;
+              const double t40 = vertices[5](1)*vertices[7](2);
+              const double t41 = t40*eta;
+              const double t42 = t3*xi;
+              const double t44 = vertices[4](1)*vertices[7](2);
+              const double t45 = t44*eta;
+              const double t46 = 2.0*t45;
+              const double t47 = -t2+t4+t7+t9+t12+2.0*t13+t17-t19+t21-t24-t27-t29-t32-t34+t37-t39-t41+2.0*t42+t46;
+              const double t48 = vertices[1](1)*vertices[2](2);
+              const double t49 = t48*xi;
+              const double t50 = 2.0*t49;
+              const double t51 = vertices[7](1)*eta;
+              const double t52 = t51*vertices[0](2);
+              const double t53 = 2.0*t52;
+              const double t54 = t51*vertices[1](2);
+              const double t55 = vertices[3](1)*vertices[5](2);
+              const double t56 = t55*eta;
+              const double t57 = t5*vertices[0](2);
+              const double t58 = 2.0*t57;
+              const double t59 = vertices[3](1)*eta;
+              const double t60 = t59*vertices[0](2);
+              const double t61 = 2.0*t60;
+              const double t62 = t15*vertices[1](2);
+              const double t63 = 2.0*t62;
+              const double t64 = vertices[0](1)*vertices[5](2);
+              const double t65 = t64*xi;
+              const double t66 = 2.0*t65;
+              const double t67 = t8*vertices[0](2);
+              const double t68 = 2.0*t67;
+              const double t69 = t51*vertices[4](2);
+              const double t70 = 2.0*t69;
+              const double t71 = vertices[1](1)*xi;
+              const double t72 = t71*vertices[4](2);
+              const double t73 = 2.0*t72;
+              const double t74 = t25*xi;
+              const double t75 = 2.0*t74;
+              const double t76 = t59*vertices[4](2);
+              const double t77 = 2.0*t76;
+              const double t78 = vertices[3](1)*vertices[7](2);
+              const double t79 = t78*zeta;
+              const double t80 = 2.0*t79;
+              const double t81 = t55*xi;
+              const double t83 = vertices[3](1)*vertices[4](2);
+              const double t84 = t83*xi;
+              const double t85 = 2.0*t84;
+              const double t86 = t83*zeta;
+              const double t87 = 2.0*t86;
+              const double t88 = vertices[3](1)*vertices[1](2);
+              const double t89 = t88*xi;
+              const double t90 = 2.0*t89;
+              const double t91 = vertices[3](1)*vertices[0](2);
+              const double t92 = t91*xi;
+              const double t93 = 2.0*t92;
+              const double t94 = t50+t53-t54-t56-t58-t61-t63+t66-t68-t70+t73-t75+t77-t80-2.0*t81+t85+t87+t90-t93;
+              const double t96 = t15*vertices[4](2);
+              const double t98 = vertices[0](1)*vertices[6](2);
+              const double t99 = t98*zeta;
+              const double t100 = vertices[4](1)*vertices[6](2);
+              const double t101 = t100*eta;
+              const double t102 = t88*eta;
+              const double t103 = t30*vertices[0](2);
+              const double t104 = 2.0*t103;
+              const double t105 = vertices[4](1)*vertices[3](2);
+              const double t106 = t105*xi;
+              const double t107 = 2.0*t106;
+              const double t108 = t105*eta;
+              const double t109 = 2.0*t108;
+              const double t110 = t71*vertices[3](2);
+              const double t111 = 2.0*t110;
+              const double t112 = t35*eta;
+              const double t113 = 2.0*t112;
+              const double t114 = vertices[0](1)*vertices[3](2);
+              const double t115 = t114*xi;
+              const double t116 = 2.0*t115;
+              const double t117 = t114*eta;
+              const double t118 = 2.0*t117;
+              const double t119 = vertices[0](1)*vertices[2](2);
+              const double t120 = t119*xi;
+              const double t121 = 2.0*t120;
+              const double t122 = t3*eta;
+              const double t123 = xi*eta;
+              const double t125 = 2.0*t114*t123;
+              const double t126 = t119*t123;
+              const double t127 = 2.0*t126;
+              const double t128 = t8*vertices[3](2);
+              const double t129 = 2.0*t128;
+              const double t130 = t5*vertices[2](2);
+              const double t132 = t35*t123;
+              const double t133 = 2.0*t132;
+              const double t134 = t98*t123;
+              const double t135 = 2.0*t134;
+              const double t136 = -2.0*t96-t99-t101+t102+t104-t107-t109-t111-t113+t116+t118-t121+t122-t125+t127+t129-2.0*t130+t133-t135;
+              const double t137 = t98*eta;
+              const double t138 = vertices[2](1)*eta;
+              const double t139 = t138*vertices[0](2);
+              const double t140 = vertices[6](1)*eta;
+              const double t141 = t140*vertices[4](2);
+              const double t142 = t140*vertices[0](2);
+              const double t143 = vertices[3](1)*vertices[6](2);
+              const double t144 = t143*zeta;
+              const double t145 = t55*zeta;
+              const double t146 = t138*vertices[4](2);
+              const double t147 = vertices[6](1)*zeta;
+              const double t148 = t147*vertices[3](2);
+              const double t149 = t147*vertices[0](2);
+              const double t150 = t64*zeta;
+              const double t151 = vertices[2](1)*vertices[7](2);
+              const double t152 = t151*zeta;
+              const double t153 = t28*eta;
+              const double t154 = vertices[1](1)*vertices[3](2);
+              const double t155 = t154*eta;
+              const double t156 = vertices[5](1)*eta;
+              const double t157 = t156*vertices[3](2);
+              const double t158 = t8*vertices[2](2);
+              const double t159 = t119*eta;
+              const double t160 = t15*vertices[5](2);
+              const double t162 = vertices[0](2)*xi;
+              const double t164 = 2.0*t30*t162;
+              const double t165 = vertices[7](2)*eta;
+              const double t166 = t5*t165;
+              const double t167 = 2.0*t166;
+              const double t168 = vertices[3](2)*eta;
+              const double t169 = t5*t168;
+              const double t170 = 2.0*t169;
+              const double t171 = t137+t139+t141-t142+t144-t145-t146-t148+t149+t150+t152+t153-t155+t157-t158-t159+2.0*t160-t164+t167-t170;
+              const double t174 = vertices[3](2)*xi;
+              const double t175 = t30*t174;
+              const double t176 = vertices[1](2)*xi;
+              const double t177 = t30*t176;
+              const double t178 = t8*t174;
+              const double t179 = vertices[2](2)*xi;
+              const double t180 = t8*t179;
+              const double t181 = t8*t176;
+              const double t182 = t8*t162;
+              const double t183 = xi*zeta;
+              const double t184 = t143*t183;
+              const double t185 = t55*t183;
+              const double t186 = t83*t183;
+              const double t187 = eta*vertices[4](2);
+              const double t188 = t15*t187;
+              const double t189 = eta*vertices[0](2);
+              const double t190 = t15*t189;
+              const double t191 = vertices[6](1)*xi;
+              const double t192 = t191*t187;
+              const double t193 = t71*t165;
+              const double t194 = t71*t168;
+              const double t195 = t51*t176;
+              const double t196 = vertices[5](2)*xi;
+              const double t197 = t59*t196;
+              const double t198 = vertices[4](2)*xi;
+              const double t199 = t59*t198;
+              const double t200 = t59*t176;
+              const double t201 = t59*t162;
+              const double t202 = t175+t177-t178+t180-t181+t182-t184+t185-t186+t188-t190-t192-t193+t194+t195+t197-t199-t200+t201;
+              const double t203 = t3*t123;
+              const double t204 = vertices[7](2)*zeta;
+              const double t205 = t15*t204;
+              const double t206 = vertices[4](2)*zeta;
+              const double t207 = t15*t206;
+              const double t208 = t71*t204;
+              const double t209 = t71*t206;
+              const double t210 = zeta*vertices[3](2);
+              const double t211 = t191*t210;
+              const double t212 = zeta*vertices[0](2);
+              const double t213 = t191*t212;
+              const double t214 = t5*t212;
+              const double t215 = t51*t162;
+              const double t216 = t35*t183;
+              const double t217 = t98*t183;
+              const double t218 = t64*t183;
+              const double t219 = t25*t183;
+              const double t220 = t51*t196;
+              const double t221 = t51*t198;
+              const double t222 = vertices[6](2)*eta;
+              const double t223 = t5*t222;
+              const double t224 = t156*t179;
+              const double t225 = t48*t123;
+              const double t226 = vertices[1](1)*vertices[6](2);
+              const double t227 = t226*t123;
+              const double t228 = -t203-t205+t207+t208-t209+t211-t213+t214-t215-t216+t217-t218+t219-t220+t221-t223+t224-t225+t227;
+              const double t230 = vertices[5](2)*eta;
+              const double t231 = t15*t230;
+              const double t233 = vertices[1](2)*eta;
+              const double t234 = t15*t233;
+              const double t235 = 2.0*t234;
+              const double t236 = t44*t123;
+              const double t237 = 2.0*t236;
+              const double t238 = t100*t123;
+              const double t240 = t105*t123;
+              const double t241 = 2.0*t240;
+              const double t242 = t191*t230;
+              const double t244 = t18*t196;
+              const double t246 = t226*t183;
+              const double t248 = t22*t183;
+              const double t249 = 2.0*t248;
+              const double t250 = t191*t233;
+              const double t252 = zeta*vertices[2](2);
+              const double t253 = t191*t252;
+              const double t255 = zeta*vertices[1](2);
+              const double t256 = t191*t255;
+              const double t258 = t5*t252;
+              const double t261 = t191*t189;
+              const double t262 = 2.0*t261;
+              const double t263 = 2.0*t114;
+              const double t264 = 2.0*t10;
+              const double t265 = t30*t179;
+              const double t266 = 2.0*t265;
+              const double t267 = -2.0*t231+t235-t237+2.0*t238+t241+2.0*t242-2.0*t244-2.0*t246+t249-2.0*t250-2.0*t253+2.0*t256+2.0*t258+t119+2.0*t105+t262-t263-t264-t266;
+              const double t268 = 2.0*t25;
+              const double t269 = 2.0*t91;
+              const double t271 = 2.0*t78*t183;
+              const double t273 = vertices[5](1)*vertices[0](2);
+              const double t274 = vertices[2](1)*vertices[0](2);
+              const double t275 = vertices[2](1)*vertices[4](2);
+              const double t276 = t5*t210;
+              const double t277 = 2.0*t276;
+              const double t278 = t33*vertices[3](2);
+              const double t279 = vertices[6](2)*zeta;
+              const double t281 = 2.0*t15*t279;
+              const double t283 = 2.0*t5*t255;
+              const double t284 = vertices[5](1)*vertices[3](2);
+              const double t285 = t51*vertices[5](2);
+              const double t286 = t268+t269+t271-2.0*t83-t3-t64+t273-t274+t275-t277+t55-t88+t154-t20+t278+t281-t283+t1-t284+t285;
+              const double t290 = vertices[5](0)*eta;
+              const double t291 = t290*t36;
+              const double t292 = vertices[0](0)*vertices[1](2);
+              const double t293 = t292*vertices[3](1);
+              const double t294 = t290*t74;
+              const double t295 = t290*vertices[2](1);
+              const double t296 = xi*vertices[7](2);
+              const double t297 = t296*zeta;
+              const double t299 = 2.0*t295*t297;
+              const double t300 = vertices[3](0)*vertices[0](2);
+              const double t301 = t300*t5;
+              const double t302 = xi*xi;
+              const double t303 = t302*vertices[7](2);
+              const double t304 = t303*zeta;
+              const double t306 = t302*vertices[6](2);
+              const double t307 = t306*zeta;
+              const double t309 = vertices[0](0)*vertices[1](1);
+              const double t310 = t309*zeta;
+              const double t311 = t179*eta;
+              const double t313 = 2.0*t310*t311;
+              const double t314 = t15*eta;
+              const double t316 = 2.0*t292*t314;
+              const double t317 = t290*vertices[1](1);
+              const double t320 = 2.0*t317*t297;
+              const double t321 = t191*eta;
+              const double t322 = t292*t321;
+              const double t323 = vertices[7](0)*vertices[1](2);
+              const double t324 = eta*vertices[4](1);
+              const double t325 = t324*xi;
+              const double t327 = 2.0*t323*t325;
+              const double t328 = vertices[3](0)*vertices[0](1);
+              const double t329 = t328*vertices[4](2);
+              const double t330 = vertices[3](0)*vertices[1](2);
+              const double t331 = t330*vertices[4](1);
+              const double t332 = t330*vertices[0](1);
+              const double t333 = t291-t293-t294-t299+t301+t295*t304-t295*t307+t313+t316-t317*t304+t320-t322+t327-t329-t331+t332;
+              const double t334 = vertices[3](0)*vertices[1](1);
+              const double t335 = t334*vertices[0](2);
+              const double t337 = vertices[1](0)*vertices[0](1);
+              const double t338 = t337*vertices[4](2);
+              const double t339 = t292*vertices[4](1);
+              const double t340 = eta*eta;
+              const double t341 = vertices[5](0)*t340;
+              const double t342 = vertices[7](1)*vertices[0](2);
+              const double t343 = t342*xi;
+              const double t344 = t341*t343;
+              const double t345 = t198*zeta;
+              const double t347 = 2.0*t317*t345;
+              const double t348 = t300*vertices[4](1);
+              const double t349 = vertices[1](1)*eta;
+              const double t350 = zeta*zeta;
+              const double t351 = t349*t350;
+              const double t352 = vertices[0](0)*vertices[5](2);
+              const double t353 = t352*xi;
+              const double t355 = zeta*t302;
+              const double t356 = t355*vertices[3](1);
+              const double t357 = t323*t356;
+              const double t358 = vertices[4](0)*vertices[1](2);
+              const double t359 = t358*vertices[0](1);
+              const double t360 = vertices[1](0)*vertices[3](1);
+              const double t361 = t360*vertices[4](2);
+              const double t362 = vertices[1](2)*vertices[6](0);
+              const double t363 = t302*eta;
+              const double t364 = t363*vertices[5](1);
+              const double t365 = t362*t364;
+              const double t366 = vertices[4](0)*eta;
+              const double t367 = t366*t350;
+              const double t368 = t191*vertices[3](2);
+              const double t370 = t300*t8;
+              const double t371 = t191*vertices[0](2);
+              const double t374 = -t335+t317*t307+t338+t339-t344-t347+t348+t351*t353+t357-t359-t361-t365-t367*t368+t370+t367*t371+t367*t13;
+              const double t377 = vertices[1](1)*t340;
+              const double t378 = t377*zeta;
+              const double t379 = vertices[7](0)*vertices[4](2);
+              const double t380 = t379*xi;
+              const double t382 = t233*t350;
+              const double t383 = vertices[3](0)*vertices[5](1);
+              const double t384 = t383*xi;
+              const double t386 = vertices[7](1)*vertices[4](2);
+              const double t387 = t386*xi;
+              const double t388 = t341*t387;
+              const double t389 = t290*t72;
+              const double t390 = vertices[3](0)*vertices[6](1);
+              const double t391 = t390*xi;
+              const double t393 = vertices[1](2)*t340;
+              const double t394 = t393*zeta;
+              const double t395 = vertices[6](0)*xi;
+              const double t396 = t395*vertices[0](1);
+              const double t398 = t395*vertices[4](1);
+              const double t400 = t290*vertices[0](1);
+              const double t403 = 2.0*t400*t297;
+              const double t404 = vertices[3](0)*vertices[2](2);
+              const double t405 = t404*zeta;
+              const double t406 = t349*xi;
+              const double t408 = 2.0*t405*t406;
+              const double t409 = t156*xi;
+              const double t411 = 2.0*t405*t409;
+              const double t412 = vertices[7](0)*eta;
+              const double t413 = t412*zeta;
+              const double t414 = vertices[0](1)*t302;
+              const double t415 = t414*vertices[5](2);
+              const double t417 = vertices[4](0)*vertices[3](1);
+              const double t418 = t252*t417;
+              const double t419 = t414*vertices[4](2);
+              const double t421 = t98*xi;
+              const double t423 = -t367*t57-t378*t380+t382*t384+t388+t389-t382*t391+t394*t396-t394*t398-t400*t307-t403-t408+t411-t413*t415+t418+t413*t419-t367*t421;
+              const double t424 = vertices[5](2)*t340;
+              const double t425 = zeta*vertices[3](0);
+              const double t426 = t425*vertices[0](1);
+              const double t427 = t424*t426;
+              const double t429 = zeta*vertices[7](0);
+              const double t430 = t429*vertices[4](1);
+              const double t431 = t424*t430;
+              const double t432 = vertices[4](0)*t340;
+              const double t433 = t432*zeta;
+              const double t435 = vertices[7](1)*vertices[5](2)*xi;
+              const double t437 = vertices[4](0)*vertices[0](2);
+              const double t438 = vertices[3](1)*xi;
+              const double t440 = 2.0*t437*t438;
+              const double t441 = vertices[1](0)*vertices[4](1);
+              const double t442 = t441*vertices[3](2);
+              const double t443 = vertices[1](1)*t350;
+              const double t444 = vertices[7](0)*vertices[0](2);
+              const double t445 = t444*xi;
+              const double t446 = t443*t445;
+              const double t447 = vertices[4](0)*vertices[1](1);
+              const double t448 = t447*vertices[3](2);
+              const double t449 = vertices[3](0)*t350;
+              const double t450 = t449*vertices[7](1);
+              const double t451 = t230*t450;
+              const double t452 = t444*t324;
+              const double t453 = vertices[1](1)*zeta;
+              const double t454 = vertices[0](0)*vertices[3](2);
+              const double t455 = t454*eta;
+              const double t457 = 2.0*t453*t455;
+              const double t458 = vertices[7](1)*vertices[1](2);
+              const double t459 = t458*xi;
+              const double t461 = vertices[0](0)*vertices[6](2);
+              const double t462 = t461*xi;
+              const double t463 = t377*t462;
+              const double t464 = vertices[2](0)*xi;
+              const double t465 = t464*vertices[0](2);
+              const double t466 = t377*t465;
+              const double t467 = t464*vertices[4](2);
+              const double t468 = t377*t467;
+              const double t469 = vertices[0](0)*vertices[4](1);
+              const double t470 = t469*vertices[3](2);
+              const double t471 = t427+t367*t65+t431+t433*t435+t440+t442+t446-t448+t451+t452+t457-t433*t459-t463-t466+t468-t470;
+              const double t474 = t355*vertices[2](1);
+              const double t475 = t323*t474;
+              const double t476 = vertices[0](1)*vertices[6](0);
+              const double t477 = t123*vertices[4](2);
+              const double t478 = t476*t477;
+              const double t479 = vertices[1](2)*t350;
+              const double t480 = vertices[5](0)*xi;
+              const double t481 = t480*vertices[0](1);
+              const double t482 = t479*t481;
+              const double t483 = vertices[0](0)*eta;
+              const double t484 = t483*zeta;
+              const double t485 = vertices[4](1)*t302;
+              const double t486 = t485*vertices[2](2);
+              const double t489 = vertices[4](0)*vertices[0](1);
+              const double t490 = t355*vertices[3](2);
+              const double t491 = t489*t490;
+              const double t492 = t309*vertices[4](2);
+              const double t493 = t355*vertices[2](2);
+              const double t494 = t489*t493;
+              const double t495 = vertices[2](0)*vertices[1](2);
+              const double t496 = t495*t485;
+              const double t497 = t464*vertices[4](1);
+              const double t499 = zeta*vertices[3](1);
+              const double t500 = t499*vertices[0](2);
+              const double t501 = t366*t500;
+              const double t502 = t303*eta;
+              const double t503 = t489*t502;
+              const double t504 = t309*vertices[3](2);
+              const double t505 = t483*t350;
+              const double t506 = t71*vertices[7](2);
+              const double t508 = vertices[0](1)*eta;
+              const double t509 = vertices[3](0)*vertices[4](2);
+              const double t510 = t509*xi;
+              const double t512 = 2.0*t508*t510;
+              const double t513 = vertices[3](0)*vertices[4](1);
+              const double t514 = t513*zeta;
+              const double t515 = t424*t514;
+              const double t516 = -t475-t478-t482+t484*t486-t351*t462-t491-t492+t494+t496+t394*t497-t501+t503+t504+t505*t506-t512-t515;
+              const double t517 = t330*xi;
+              const double t519 = 2.0*t508*t517;
+              const double t520 = vertices[3](1)*t302;
+              const double t521 = t520*vertices[1](2);
+              const double t523 = zeta*vertices[4](0);
+              const double t524 = t523*vertices[7](1);
+              const double t525 = t424*t524;
+              const double t526 = t520*vertices[0](2);
+              const double t528 = vertices[2](1)*t302;
+              const double t529 = t528*vertices[5](2);
+              const double t531 = t210*xi;
+              const double t533 = 2.0*t489*t531;
+              const double t534 = t230*t426;
+              const double t538 = 2.0*t508*zeta*t517;
+              const double t540 = t528*vertices[4](2);
+              const double t542 = vertices[7](0)*vertices[3](2);
+              const double t543 = t542*xi;
+              const double t544 = t443*t543;
+              const double t545 = t528*vertices[1](2);
+              const double t547 = t528*vertices[0](2);
+              const double t549 = t252*t489;
+              const double t550 = vertices[1](1)*t302;
+              const double t551 = t550*vertices[5](2);
+              const double t553 = t519-t413*t521-t525+t413*t526-t413*t529+t533-t534+t378*t465-t538+t505*t38+t413*t540-t544+t413*t545-t413*t547-t549+t413*t551;
+              const double t555 = t449*vertices[4](1);
+              const double t556 = t230*t555;
+              const double t557 = t550*vertices[4](2);
+              const double t559 = vertices[6](0)*eta;
+              const double t560 = t559*zeta;
+              const double t562 = t300*xi;
+              const double t564 = t230*zeta;
+              const double t566 = 2.0*t564*t497;
+              const double t568 = vertices[4](0)*vertices[2](1);
+              const double t569 = t568*xi;
+              const double t571 = 2.0*t564*t569;
+              const double t576 = t464*vertices[0](1);
+              const double t578 = t520*vertices[4](2);
+              const double t580 = t412*t350;
+              const double t584 = 2.0*t453*t353;
+              const double t585 = -t556-t413*t557-t560*t540-t378*t562+t566-t378*t467-t571-t560*t545+t560*t547-t560*t551+t560*t557-t394*t576-t413*t578+t580*t81+t560*t578+t584;
+              const double t586 = vertices[0](0)*vertices[3](1);
+              const double t587 = t586*vertices[4](2);
+              const double t588 = t489*vertices[3](2);
+              const double t589 = vertices[3](0)*vertices[2](1);
+              const double t590 = t589*zeta;
+              const double t591 = t233*xi;
+              const double t593 = 2.0*t590*t591;
+              const double t594 = t441*vertices[0](2);
+              const double t595 = vertices[0](0)*vertices[7](1);
+              const double t596 = t595*t187;
+              const double t597 = t302*vertices[7](1);
+              const double t598 = t597*zeta;
+              const double t599 = t495*t598;
+              const double t600 = xi*vertices[7](1);
+              const double t601 = t600*zeta;
+              const double t602 = t495*t601;
+              const double t603 = vertices[7](0)*t350;
+              const double t604 = t603*vertices[3](1);
+              const double t605 = t230*t604;
+              const double t606 = vertices[5](0)*vertices[0](2);
+              const double t607 = t606*t438;
+              const double t608 = t508*t350;
+              const double t609 = vertices[4](0)*vertices[2](2);
+              const double t610 = t609*xi;
+              const double t614 = vertices[0](1)*zeta;
+              const double t615 = t614*t517;
+              const double t616 = t302*vertices[6](1);
+              const double t617 = t616*zeta;
+              const double t618 = t330*t617;
+              const double t619 = t330*t598;
+              const double t620 = vertices[1](0)*eta;
+              const double t621 = t620*t79;
+              const double t622 = vertices[3](0)*vertices[5](2);
+              const double t623 = t622*xi;
+              const double t625 = t587+t588+t593-t594+t596+t599-t602-t605-t607+t608*t610+t560*t521-t560*t526+t615+t618-t619+t621-t351*t623;
+              const double t629 = t523*vertices[3](1);
+              const double t631 = 2.0*t230*t629;
+              const double t634 = 2.0*t413*t84;
+              const double t635 = vertices[5](0)*vertices[0](1);
+              const double t636 = t306*eta;
+              const double t637 = t635*t636;
+              const double t638 = vertices[7](0)*vertices[0](1);
+              const double t639 = t638*t490;
+              const double t640 = t495*t617;
+              const double t642 = 2.0*t413*t89;
+              const double t643 = t447*xi;
+              const double t645 = 2.0*t564*t643;
+              const double t646 = t424*t328;
+              const double t647 = t480*vertices[0](2);
+              const double t649 = 2.0*t453*t647;
+              const double t650 = vertices[0](0)*t350;
+              const double t651 = t650*vertices[7](1);
+              const double t652 = t230*t651;
+              const double t653 = t485*vertices[3](2);
+              const double t654 = t483*t653;
+              const double t655 = t429*vertices[0](1);
+              const double t656 = t424*t655;
+              const double t658 = 2.0*t413*t92;
+              const double t660 = 2.0*t413*t96;
+              const double t661 = t230*xi;
+              const double t663 = 2.0*t590*t661;
+              const double t664 = -t631+t560*t529+t634+t637+t639-t640+t642+t645-t646-t649-t652+t654-t656-t658-t660-t663;
+              const double t665 = t377*t562;
+              const double t666 = t437*t520;
+              const double t667 = t143*xi;
+              const double t669 = t255*xi;
+              const double t671 = 2.0*t489*t669;
+              const double t673 = 2.0*t230*t514;
+              const double t674 = vertices[1](0)*t350;
+              const double t675 = t674*t25;
+              const double t676 = t635*t493;
+              const double t677 = t230*t576;
+              const double t678 = t635*t502;
+              const double t679 = vertices[2](1)*t350;
+              const double t680 = t679*t509;
+              const double t681 = t377*t510;
+              const double t682 = t638*t493;
+              const double t683 = t523*vertices[0](1);
+              const double t685 = 2.0*t230*t683;
+              const double t687 = xi*vertices[4](1);
+              const double t688 = t687*zeta;
+              const double t690 = 2.0*t230*vertices[1](0)*t688;
+              const double t691 = t230*t497;
+              const double t692 = t296*eta;
+              const double t693 = t635*t692;
+              const double t694 = t665-t666-t580*t667-t671+t673+t675-t676+t677-t678-t680-t681-t682+t685-t690-t691+t693;
+              const double t696 = t222*t514;
+              const double t697 = vertices[6](2)*t340;
+              const double t698 = t697*t430;
+              const double t699 = t222*t426;
+              const double t700 = t18*t340;
+              const double t701 = vertices[7](0)*vertices[5](2);
+              const double t702 = t701*xi;
+              const double t704 = t222*t350;
+              const double t705 = vertices[1](0)*xi;
+              const double t706 = t705*vertices[4](1);
+              const double t708 = t508*vertices[4](0);
+              const double t710 = 2.0*t708*t669;
+              const double t711 = vertices[4](0)*t350;
+              const double t712 = t711*vertices[3](1);
+              const double t713 = t222*t712;
+              const double t714 = t711*vertices[0](1);
+              const double t715 = t222*t714;
+              const double t716 = t697*t524;
+              const double t717 = t603*vertices[3](2);
+              const double t718 = t140*t717;
+              const double t720 = vertices[6](0)*t340;
+              const double t721 = t720*zeta;
+              const double t724 = 2.0*t233*t569;
+              const double t725 = t323*xi;
+              const double t727 = vertices[2](0)*t350;
+              const double t728 = vertices[7](1)*vertices[3](2);
+              const double t729 = t727*t728;
+              const double t730 = vertices[0](0)*t340;
+              const double t731 = t730*t89;
+              const double t732 = -t696-t698+t699-t700*t702-t704*t706+t710-t713+t715+t716-t718+t560*t415+t721*t92-t724+t700*t725+t729+t731;
+              const double t733 = vertices[0](0)*vertices[5](1);
+              const double t734 = t733*xi;
+              const double t735 = t233*t734;
+              const double t736 = vertices[2](0)*zeta;
+              const double t737 = t736*t83;
+              const double t738 = t720*t86;
+              const double t739 = vertices[2](2)*t350;
+              const double t740 = t739*t384;
+              const double t741 = t377*t379;
+              const double t744 = t739*t391;
+              const double t746 = 2.0*t233*t576;
+              const double t747 = t252*xi;
+              const double t748 = t638*t747;
+              const double t750 = 2.0*t233*t497;
+              const double t751 = t469*zeta;
+              const double t753 = 2.0*t230*t751;
+              const double t754 = t233*t604;
+              const double t755 = vertices[3](0)*vertices[7](1);
+              const double t756 = t755*zeta;
+              const double t757 = t233*t756;
+              const double t759 = 2.0*t233*t683;
+              const double t760 = t736*t91;
+              const double t761 = -t735-t737+t738+t740-t741-t700*t517+t700*t623-t744-t746+t748+t750-t753+t754+t757-t759+t760;
+              const double t764 = t727*t25;
+              const double t765 = vertices[0](0)*vertices[6](1);
+              const double t766 = t765*xi;
+              const double t767 = t424*t766;
+              const double t768 = vertices[0](0)*vertices[2](1);
+              const double t769 = t768*xi;
+              const double t770 = t424*t769;
+              const double t771 = t233*t629;
+              const double t773 = t233*t555;
+              const double t774 = t393*t655;
+              const double t775 = t309*t165;
+              const double t776 = t233*t651;
+              const double t777 = t393*t514;
+              const double t778 = vertices[6](1)*t340;
+              const double t779 = zeta*vertices[0](0);
+              const double t780 = t779*vertices[3](2);
+              const double t781 = t778*t780;
+              const double t782 = vertices[3](1)*t350;
+              const double t783 = t782*vertices[7](2);
+              const double t784 = t559*t783;
+              const double t785 = t638*t669;
+              const double t786 = t476*t490;
+              const double t787 = t140*t350;
+              const double t788 = vertices[3](0)*vertices[7](2);
+              const double t789 = t788*xi;
+              const double t791 = t674*t728;
+              const double t792 = vertices[1](0)*zeta;
+              const double t793 = t792*t91;
+              const double t794 = -t764-t767+t770+3.0*t771+t773+t774+t775+t776+t777-t781-t784+t785-t786-t787*t789-t791-t793;
+              const double t795 = t233*t450;
+              const double t796 = t300*t598;
+              const double t797 = t300*t617;
+              const double t798 = t782*vertices[4](2);
+              const double t799 = t559*t798;
+              const double t800 = t476*t493;
+              const double t801 = t674*t35;
+              const double t802 = t635*t490;
+              const double t803 = t230*t756;
+              const double t804 = t768*t297;
+              const double t805 = t412*t26;
+              const double t806 = t358*xi;
+              const double t809 = 2.0*t413*t81;
+              const double t810 = t156*t350;
+              const double t812 = t156*zeta;
+              const double t814 = 2.0*t812*t467;
+              const double t816 = 2.0*t300*t601;
+              const double t817 = t191*zeta;
+              const double t818 = t300*t817;
+              const double t819 = -t795+t796-t797+t799+t800-t801+t802-t803+t804+t805-t608*t806-t809+t810*t806-t814-t816+t818;
+              const double t821 = t252*t340;
+              const double t822 = t705*vertices[3](1);
+              const double t824 = vertices[5](1)*t340;
+              const double t825 = t824*zeta;
+              const double t826 = t395*vertices[4](2);
+              const double t828 = t290*zeta;
+              const double t831 = vertices[0](2)*vertices[6](0);
+              const double t832 = t831*t325;
+              const double t833 = t705*vertices[7](1);
+              const double t835 = t479*t638;
+              const double t836 = vertices[7](0)*t340;
+              const double t837 = t836*zeta;
+              const double t838 = t100*xi;
+              const double t840 = t429*vertices[4](2);
+              const double t841 = t778*t840;
+              const double t843 = t412*vertices[0](1);
+              const double t844 = t739*t843;
+              const double t846 = t230*t350;
+              const double t848 = t429*vertices[0](2);
+              const double t849 = t778*t848;
+              const double t850 = t509*zeta;
+              const double t851 = t778*t850;
+              const double t852 = vertices[4](0)*vertices[7](1);
+              const double t853 = t852*eta;
+              const double t854 = t255*t853;
+              const double t855 = -t821*t822-t825*t826+t828*t545-t828*t547+t832+t821*t833+t835+t837*t838+t841+t580*t421+t844-t580*t65+t846*t706-t849-t851-t854;
+              const double t857 = t425*vertices[0](2);
+              const double t858 = t778*t857;
+              const double t860 = vertices[2](0)*vertices[0](2);
+              const double t861 = t860*t601;
+              const double t864 = vertices[1](0)*vertices[7](1);
+              const double t865 = t864*t210;
+              const double t866 = t860*t617;
+              const double t867 = t233*t481;
+              const double t868 = t429*vertices[3](1);
+              const double t869 = t233*t868;
+              const double t870 = t449*vertices[7](2);
+              const double t871 = t140*t870;
+              const double t872 = t337*t204;
+              const double t873 = t140*t780;
+              const double t874 = t230*t712;
+              const double t875 = t449*vertices[4](2);
+              const double t876 = t140*t875;
+              const double t877 = t230*t714;
+              const double t878 = t337*t198;
+              const double t879 = -t560*t419+t858-t846*t833+t861+t580*t368-t837*t42+t865+t866+t867-t869+t871+t872+t873+t874-t876-t877-t878;
+              const double t884 = t559*t26;
+              const double t885 = t679*eta;
+              const double t887 = vertices[0](0)*vertices[7](2);
+              const double t888 = t887*zeta;
+              const double t889 = t778*t888;
+              const double t891 = t222*t651;
+              const double t893 = vertices[0](1)*t350;
+              const double t894 = vertices[7](0)*vertices[2](2);
+              const double t895 = t894*xi;
+              const double t896 = t893*t895;
+              const double t897 = t330*t485;
+              const double t898 = t697*t514;
+              const double t899 = t893*t725;
+              const double t900 = t697*t655;
+              const double t901 = t222*t604;
+              const double t903 = t255*t586;
+              const double t906 = t884+t885*t623+t889+t721*t81+t891-t721*t84+t896-t897+t898-t899+t900+t901+t704*t833+t903-t885*t353+t885*t462;
+              const double t907 = t697*t426;
+              const double t908 = vertices[1](0)*vertices[5](1);
+              const double t909 = t908*zeta;
+              const double t913 = t893*t806;
+              const double t914 = t222*t450;
+              const double t915 = t222*t555;
+              const double t917 = t302*vertices[5](2);
+              const double t918 = t360*t917;
+              const double t919 = t393*t524;
+              const double t920 = t358*t321;
+              const double t921 = t412*t86;
+              const double t922 = t290*t547;
+              const double t923 = vertices[7](0)*vertices[1](1);
+              const double t924 = t923*t187;
+              const double t925 = t233*t714;
+              const double t926 = t650*vertices[4](1);
+              const double t927 = t222*t926;
+              const double t928 = -t907+t909*t502-t721*t89+t608*t725+t913-t914+t915-t608*t895+t918+t919+t920-t921+t922+t924+t925-t927;
+              const double t930 = vertices[7](1)*t350;
+              const double t931 = t930*vertices[3](2);
+              const double t932 = t620*t931;
+              const double t933 = t412*t500;
+              const double t935 = 2.0*t413*t72;
+              const double t936 = t341*t342;
+              const double t937 = t414*vertices[2](2);
+              const double t938 = t366*t937;
+              const double t940 = 2.0*t413*t74;
+              const double t941 = t341*t91;
+              const double t942 = t520*vertices[5](2);
+              const double t944 = t341*t386;
+              const double t945 = t363*vertices[4](1);
+              const double t946 = t444*t945;
+              const double t947 = t705*vertices[4](2);
+              const double t949 = 2.0*t812*t947;
+              const double t950 = t559*t350;
+              const double t952 = t824*t840;
+              const double t953 = t233*t712;
+              const double t954 = t252*t822;
+              const double t955 = t366*t114;
+              const double t956 = t932+t933+t935+t936+t938-t940-t941+t413*t942-t944+t946+t949-t950*t84-t952-t953-t954-t955;
+              const double t957 = t559*t931;
+              const double t958 = vertices[2](0)*vertices[1](1);
+              const double t959 = t958*t162;
+              const double t960 = t252*t481;
+              const double t961 = t44*xi;
+              const double t963 = vertices[7](0)*vertices[2](1);
+              const double t964 = t963*xi;
+              const double t966 = t252*t843;
+              const double t967 = t923*xi;
+              const double t969 = t697*zeta;
+              const double t970 = t480*vertices[3](1);
+              const double t972 = t480*vertices[7](1);
+              const double t975 = vertices[6](2)*xi;
+              const double t976 = t975*zeta;
+              const double t977 = t586*t976;
+              const double t978 = t824*t848;
+              const double t979 = vertices[3](0)*eta;
+              const double t980 = t979*vertices[4](1);
+              const double t982 = 2.0*t252*t980;
+              const double t983 = t444*t364;
+              const double t984 = vertices[7](0)*vertices[4](1);
+              const double t985 = t393*t984;
+              const double t986 = t824*t850;
+              const double t987 = t957-t959-t960-t721*t961+t704*t964+t966-t704*t967-t969*t970+t969*t972-t828*t521+t977+t978+t982-t983+t985+t986;
+              const double t991 = t252*t734;
+              const double t992 = t309*t297;
+              const double t993 = t824*t857;
+              const double t994 = t156*t870;
+              const double t996 = t252*t384;
+              const double t997 = t334*xi;
+              const double t998 = t252*t997;
+              const double t1000 = 2.0*t812*t510;
+              const double t1001 = t15*vertices[7](2);
+              const double t1004 = t979*vertices[0](1);
+              const double t1006 = 2.0*t252*t1004;
+              const double t1007 = t432*vertices[3](1);
+              const double t1008 = t252*t1007;
+              const double t1009 = t156*t875;
+              const double t1010 = t730*vertices[3](1);
+              const double t1011 = t252*t1010;
+              const double t1012 = t730*vertices[7](1);
+              const double t1013 = t252*t1012;
+              const double t1014 = t950*t96+t991+t992-t993-t994+t721*t106-t996+t998+t1000-t950*t1001+t828*t526-t1006+t1008+t1009-t1011+t1013;
+              const double t1016 = 2.0*t812*t517;
+              const double t1019 = t412*vertices[4](1);
+              const double t1020 = t252*t1019;
+              const double t1021 = t824*t888;
+              const double t1022 = t739*t396;
+              const double t1024 = 2.0*t828*t96;
+              const double t1025 = t252*t708;
+              const double t1026 = t638*t210;
+              const double t1027 = vertices[4](0)*vertices[3](2);
+              const double t1028 = t614*t1027;
+              const double t1029 = vertices[0](0)*vertices[2](2);
+              const double t1030 = t1029*xi;
+              const double t1032 = 2.0*t812*t1030;
+              const double t1034 = t290*t83;
+              const double t1035 = t290*t350;
+              const double t1038 = t290*t91;
+              const double t1039 = -t1016+t580*t57-t580*t13-t1020-t1021-t1022+t1024+t1025+t1026-t1028-t1032-t821*t384-t1034-t1035*t74+t821*t997+t1038;
+              const double t1041 = t290*t25;
+              const double t1042 = t739*t734;
+              const double t1043 = t334*t187;
+              const double t1044 = 2.0*t1043;
+              const double t1045 = vertices[7](0)*vertices[5](1);
+              const double t1046 = t1045*xi;
+              const double t1049 = t156*t947;
+              const double t1050 = t78*xi;
+              const double t1054 = t341*t83;
+              const double t1055 = t395*vertices[3](1);
+              const double t1056 = t739*t1055;
+              const double t1057 = t156*t465;
+              const double t1058 = t739*eta;
+              const double t1060 = t252*t853;
+              const double t1063 = t1041-t1042-t1044+t821*t1046-t821*t967-t1049-t1035*t1050+t950*t506-t950*t72+t1054+t1056-t1057-t1058*t766+t1060-t721*t343+t1058*t734;
+              const double t1064 = t35*xi;
+              const double t1067 = t559*t500;
+              const double t1069 = t290*t521;
+              const double t1070 = t290*t114;
+              const double t1071 = t290*t526;
+              const double t1074 = t341*t105;
+              const double t1075 = vertices[4](0)*vertices[6](1);
+              const double t1076 = t1075*xi;
+              const double t1077 = t424*t1076;
+              const double t1078 = t341*t35;
+              const double t1079 = t156*t467;
+              const double t1080 = t341*t114;
+              const double t1081 = t156*t510;
+              const double t1082 = t788*zeta;
+              const double t1083 = t156*t1082;
+              const double t1085 = 2.0*t156*t850;
+              const double t1086 = -t950*t1064+t950*t74+t1067-t721*t435+t1069-t1070-t1071+t1058*t391-t1058*t384-t1074+t1077-t1078+t1079+t1080-t1081+t1083-t1085;
+              const double t1090 = t393*t426;
+              const double t1091 = t424*t569;
+              const double t1092 = t156*t517;
+              const double t1093 = t831*t945;
+              const double t1094 = t230*t926;
+              const double t1096 = t923*t189;
+              const double t1098 = t395*vertices[0](2);
+              const double t1099 = t824*t1098;
+              const double t1100 = t824*t826;
+              const double t1102 = t559*t86;
+              const double t1103 = t290*t545;
+              const double t1104 = t831*t364;
+              const double t1106 = t156*t610;
+              const double t1107 = -t1090-t1091+t1092-t1093+t1094+t721*t387-t1096+t787*t610-t1099+t1100+t721*t459-t1102-t1103+t1104-t846*t964-t1106;
+              const double t1109 = t341*t44;
+              const double t1110 = t156*t806;
+              const double t1111 = t424*zeta;
+              const double t1114 = t156*t1030;
+              const double t1115 = t444*t409;
+              const double t1116 = t893*vertices[7](2);
+              const double t1117 = t559*t1116;
+              const double t1119 = t893*vertices[4](2);
+              const double t1120 = t559*t1119;
+              const double t1123 = 2.0*t444*t325;
+              const double t1124 = t393*t430;
+              const double t1125 = t603*vertices[0](1);
+              const double t1126 = t233*t1125;
+              const double t1127 = t412*vertices[3](1);
+              const double t1128 = t739*t1127;
+              const double t1129 = t341*t961;
+              const double t1130 = t846*t967+t1109+t1110+t1111*t569+t1111*t766+t1114+t1115+t1117-t1111*t769-t1120-t1111*t1076-t1123-t1124-t1126-t1128-t1129;
+              const double t1132 = t300*t485;
+              const double t1133 = vertices[4](0)*vertices[5](1);
+              const double t1134 = t1133*eta;
+              const double t1136 = 2.0*t1134*t669;
+              const double t1137 = t156*t717;
+              const double t1138 = t341*t838;
+              const double t1139 = t393*t629;
+              const double t1140 = t499*vertices[0](0);
+              const double t1142 = 2.0*t1140*t311;
+              const double t1143 = t290*t783;
+              const double t1144 = t341*t106;
+              const double t1145 = t424*t576;
+              const double t1146 = t363*vertices[4](2);
+              const double t1147 = t768*t1146;
+              const double t1148 = t489*t176;
+              const double t1149 = t424*t497;
+              const double t1150 = t302*vertices[3](2);  
+              const double t1151 = t635*t1150;
+              const double t1152 = t464*vertices[7](1);
+              const double t1154 = t424*t396;
+              const double t1156 = t1132-t1136+t1137+t1138-t1139-t1142+t1143+t1144-t1145+t1147+t1148+t1149-t1151+t846*t1152+t1154-t560*t942;
+              const double t1157 = t424*t398;
+              const double t1159 = t778*zeta;
+              const double t1160 = t480*vertices[3](2);
+              const double t1162 = t302*vertices[5](1);
+              const double t1163 = t300*t1162;
+              const double t1164 = t454*xi;
+              const double t1167 = t302*vertices[2](2);
+              const double t1168 = t635*t1167;
+              const double t1171 = t341*zeta;
+              const double t1173 = t362*t356;
+              const double t1176 = t705*vertices[7](2);
+              const double t1178 = t705*vertices[3](2);
+              const double t1180 = t975*eta;
+              const double t1181 = t441*t1180;
+              const double t1182 = t523*vertices[3](2);
+              const double t1183 = t140*t1182;
+              const double t1184 = -t1157+t382*t766+t1159*t1160-t1163+t1159*t1164-t382*t734+t1168-t787*t895+t787*t725+t1171*t961-t1173-t1171*t838-t787*t806+t1159*t1176-t1159*t1178+t1181-t1183;
+              const double t1188 = t290*t798;
+              const double t1189 = t424*t984;
+              const double t1190 = t140*t857;
+              const double t1191 = t523*vertices[0](2);
+              const double t1192 = t140*t1191;
+              const double t1193 = vertices[5](0)*vertices[1](2);
+              const double t1194 = t183*vertices[3](1);
+              const double t1196 = 2.0*t1193*t1194;
+              const double t1197 = t183*vertices[0](1);
+              const double t1199 = 2.0*t1193*t1197;
+              const double t1200 = t860*t1162;
+              const double t1201 = t362*t1197;
+              const double t1202 = vertices[0](0)*vertices[4](2);
+              const double t1203 = t1202*zeta;
+              const double t1204 = t140*t1203;
+              const double t1205 = t230*t513;
+              const double t1206 = t480*vertices[7](2);
+              const double t1211 = t362*t1194;
+              const double t1212 = -t1171*t106-t1188-t1189-t1190+t1192-t1196+t1199+t1200-t1201-t1204-t1205-t1159*t1206+t1171*t42-t821*t972-t810*t610+t1211;
+              const double t1213 = vertices[7](1)*t340;
+              const double t1214 = t1213*zeta;
+              const double t1216 = t489*t1150;
+              const double t1218 = t334*t198;
+              const double t1219 = 2.0*t1218;
+              const double t1220 = t424*t595;
+              const double t1222 = t334*t196;
+              const double t1224 = 2.0*t1134*t747;
+              const double t1225 = t230*t769;
+              const double t1227 = t324*zeta;
+              const double t1229 = 2.0*t1227*t623;
+              const double t1230 = t424*t852;
+              const double t1232 = t483*vertices[4](1);
+              const double t1233 = t252*t1232;
+              const double t1234 = t489*t1167;
+              const double t1235 = t156*t780;
+              const double t1236 = -t1214*t1030+t1216+t1035*t1001-t1219-t1220-t1035*t96+t1222+t1224-t1225-t1035*t506-t1229+t1230+t1035*t72-t1233-t1234-t1235;
+              const double t1238 = t739*t481;
+              const double t1240 = 2.0*t828*t89;
+              const double t1241 = t334*t204;
+              const double t1242 = t255*t769;
+              const double t1243 = t739*t970;
+              const double t1244 = t586*eta;
+              const double t1246 = 2.0*t255*t1244;
+              const double t1250 = 2.0*t489*t692;
+              const double t1251 = t864*t747;
+              const double t1252 = vertices[1](0)*vertices[6](1);
+              const double t1253 = t1252*t490;
+              const double t1254 = t362*t945;
+              const double t1255 = t212*xi;
+              const double t1256 = t864*t1255;
+              const double t1257 = t453*t300;
+              const double t1258 = t290*vertices[3](1);
+              const double t1260 = 2.0*t1258*t297;
+              const double t1261 = t1252*t493;
+              const double t1262 = t1238+t1240+t1241+t1242-t1243-t1246+t1035*t1064+t1171*t343-t1250+t1251-t1253+t1254+t1256+t1257+t1260+t1261;
+              const double t1263 = t337*t692;
+              const double t1264 = t489*t165;
+              const double t1265 = t824*t462;
+              const double t1266 = t337*t1180;
+              const double t1268 = 2.0*t453*t1202;
+              const double t1269 = t489*t1180;
+              const double t1271 = t443*t623;
+              const double t1272 = t443*t542;
+              const double t1273 = t174*eta;
+              const double t1275 = 2.0*t337*t1273;
+              const double t1277 = 2.0*t337*t311;
+              const double t1279 = 2.0*t1258*t345;
+              const double t1280 = t479*t417;
+              const double t1281 = t443*t462;
+              const double t1282 = t864*t493;
+              const double t1283 = t864*t490;
+              const double t1284 = t443*t353;
+              const double t1285 = t1263+t1264+t1265-t1266+t1268+t1269+t821*t970+t1271+t1272-t1275+t1277-t1279+t1280+t1281-t1282+t1283-t1284;
+              const double t1291 = t393*t417;
+              const double t1292 = t393*t595;
+              const double t1293 = t728*xi;
+              const double t1294 = t727*t1293;
+              const double t1296 = 2.0*t156*t1182;
+              const double t1298 = 2.0*t290*t26;
+              const double t1299 = t393*t586;
+              const double t1300 = vertices[3](0)*vertices[6](2);
+              const double t1301 = t1300*xi;
+              const double t1302 = t443*t1301;
+              const double t1303 = t230*t655;
+              const double t1305 = 2.0*t156*t1191;
+              const double t1306 = t424*t629;
+              const double t1307 = t429*vertices[1](1);
+              const double t1309 = 2.0*t1307*t661;
+              const double t1310 = t377*t380;
+              const double t1311 = t424*t1140;
+              const double t1313 = 2.0*t156*t1203;
+              const double t1314 = t156*t857;
+              const double t1315 = t479*t513;
+              const double t1316 = t1291+t1292-t1294+t1296-t1298-t1299-t1302-t1303-t1305+t1306-t1309+t1310-t1311+t1313+t1314-t1315;
+              const double t1317 = t230*t1125;
+              const double t1318 = t595*zeta;
+              const double t1319 = t424*t1318;
+              const double t1320 = t638*t187;
+              const double t1322 = t328*t187;
+              const double t1323 = t377*t445;
+              const double t1325 = t252*t586;
+              const double t1326 = t479*t755;
+              const double t1327 = t606*t528;
+              const double t1328 = t233*t469;
+              const double t1330 = t393*t1318;
+              const double t1332 = t222*t629;
+              const double t1334 = t1317+t1319-t1320-t846*t643+t1322-t1323-t825*t462-t1325+t1326-t1327-t1328+t846*t569-t1330-t1171*t387+t1332-t846*t497;
+              const double t1338 = t328*t204;
+              const double t1340 = t290*t500;
+              const double t1342 = t230*t1140;
+              const double t1343 = t328*t196;
+              const double t1346 = 2.0*t328*t198;
+              const double t1347 = t697*t1318;
+              const double t1351 = t697*t1140;
+              const double t1352 = t393*t1140;
+              const double t1353 = t825*t1030+t1171*t84-t1338-t1171*t92-t1340-t704*t569+t1342-t1343+t704*t643+t1346-t1347+t810*t895-t810*t725+t969*t822+t1351+t1352;
+              const double t1355 = t697*t629;
+              const double t1356 = t290*t1116;
+              const double t1357 = t824*t780;
+              const double t1358 = t222*t751;
+              const double t1359 = t606*t520;
+              const double t1360 = t222*t683;
+              const double t1361 = t328*t176;
+              const double t1362 = t222*t1140;
+              const double t1363 = t222*t1125;
+              const double t1364 = t341*t86;
+              const double t1365 = vertices[2](0)*vertices[0](1);
+              const double t1366 = t1365*t198;
+              const double t1368 = t290*t1119;
+              const double t1369 = t290*t128;
+              const double t1370 = t635*t174;
+              const double t1371 = -t969*t833-t1355-t1356+t1357+t1358+t1359-t1360-t1361-t1362-t1363-t1364-t1366+t704*t497+t1368+t1369+t1370;
+              const double t1374 = t479*t595;
+              const double t1375 = t424*t513;
+              const double t1376 = t424*t638;
+              const double t1377 = t230*t328;
+              const double t1378 = t489*t179;
+              const double t1379 = vertices[1](0)*t340;
+              const double t1380 = t30*vertices[7](2);
+              const double t1381 = t1379*t1380;
+              const double t1382 = t323*t508;
+              const double t1384 = t1379*t67;
+              const double t1386 = t620*zeta;
+              const double t1388 = 2.0*t1386*t65;
+              const double t1389 = t1379*t500;
+              const double t1390 = t930*vertices[0](2);
+              const double t1391 = t620*t1390;
+              const double t1392 = t341*t84;
+              const double t1393 = t8*vertices[4](2);
+              const double t1394 = t1379*t1393;
+              const double t1396 = -t1374+t1375+t1376+t1377+t1378+t1381+t1382+t1058*t970+t1384+t1258*t307+t1388-t1389-t1391-t1392-t1394-t1058*t481;
+              const double t1398 = 2.0*t1386*t11;
+              const double t1400 = 2.0*t1386*t16;
+              const double t1401 = t739*t708;
+              const double t1402 = t309*t196;
+              const double t1403 = t441*eta;
+              const double t1405 = 2.0*t1403*t747;
+              const double t1406 = t341*t92;
+              const double t1407 = t864*eta;
+              const double t1409 = 2.0*t1407*t531;
+              const double t1410 = t18*t1027;
+              const double t1412 = 2.0*t1407*t747;
+              const double t1413 = t18*t437;
+              const double t1414 = t330*t324;
+              const double t1415 = 2.0*t1414;
+              const double t1416 = t358*t15;
+              const double t1417 = t290*t79;
+              const double t1418 = t1252*eta;
+              const double t1420 = t736*t106;
+              const double t1421 = t736*t13;
+              const double t1422 = t1398+t1400-t1401-t1402+t1405+t1406+t1409-t1410-t1412+t1413+t1415+t1416-t1417+t1418*t490-t1420+t1421;
+              const double t1424 = t292*t8;
+              const double t1425 = t292*t5;
+              const double t1427 = 2.0*t736*t108;
+              const double t1428 = t424*t586;
+              const double t1429 = t18*t300;
+              const double t1430 = t736*t110;
+              const double t1431 = t18*t1202;
+              const double t1432 = t432*vertices[7](1);
+              const double t1433 = t252*t1432;
+              const double t1434 = xi*vertices[0](1);
+              const double t1435 = t495*t1434;
+              const double t1436 = t736*t112;
+              const double t1437 = t736*t115;
+              const double t1438 = t679*t542;
+              const double t1439 = t393*t852;
+              const double t1440 = t1162*vertices[1](2);
+              const double t1441 = t736*t1440;
+              const double t1443 = 2.0*t736*t117;
+              const double t1444 = vertices[7](0)*vertices[3](1);
+              const double t1445 = t739*t1444;
+              const double t1446 = t1424+t1425-t1427+t1428-t1429-t1430-t1431-t1433+t1435-t1436+t1437-t1438-t1439+t1441+t1443+t1445;
+              const double t1447 = t736*vertices[0](1);
+              const double t1449 = 2.0*t1447*t692;
+              const double t1450 = t1162*vertices[0](2);
+              const double t1451 = t736*t1450;
+              const double t1453 = t739*t595;
+              const double t1454 = t290*t84;
+              const double t1456 = 2.0*t290*t86;
+              const double t1458 = 2.0*t1447*t1273;
+              const double t1460 = t736*t38;
+              const double t1461 = t739*t513;
+              const double t1462 = t736*t45;
+              const double t1464 = 2.0*t328*t297;
+              const double t1465 = t736*t52;
+              const double t1466 = t736*t57;
+              const double t1467 = t349*t437;
+              const double t1469 = 2.0*t349*t300;
+              const double t1471 = 2.0*t736*t60;
+              const double t1472 = t1449-t1451+t1058*t396+t1453+t1454+t1456-t1458-t1058*t1055+t1460+t1461+t1462+t1464+t1465-t1466-t1467+t1469-t1471;
+              const double t1476 = t349*t1202;
+              const double t1477 = t739*t755;
+              const double t1478 = t620*t350;
+              const double t1480 = t736*t69;
+              const double t1481 = t736*t65;
+              const double t1482 = t328*t976;
+              const double t1483 = t252*t328;
+              const double t1485 = vertices[4](1)*t350;
+              const double t1486 = t1485*vertices[3](2);
+              const double t1487 = t620*t1486;
+              const double t1489 = 2.0*t1386*t13;
+              const double t1490 = t290*t89;
+              const double t1491 = t252*t513;
+              const double t1492 = t1485*vertices[0](2);
+              const double t1493 = t620*t1492;
+              const double t1494 = t1386*t106;
+              const double t1496 = t476*t531;
+              const double t1497 = t1379*t31;
+              const double t1498 = t1476-t1477-t1478*t1293-t1480+t1481-t1482+t1483+t1478*t343-t1487+t1489-t1490-t1491+t1493-4.0*t1494+t1496-t1497;
+              const double t1500 = t393*t328;
+              const double t1501 = t1379*t36;
+              const double t1502 = t377*t454;
+              const double t1503 = t635*t531;
+              const double t1505 = 2.0*t489*t174;
+              const double t1506 = t453*t1027;
+              const double t1507 = 2.0*t1506;
+              const double t1508 = t290*t96;
+              const double t1509 = t1162*vertices[3](2);
+              const double t1511 = t393*t769;
+              const double t1513 = 2.0*t453*t437;
+              const double t1515 = 2.0*t864*t531;
+              const double t1517 = 2.0*t792*t57;
+              const double t1518 = t792*t45;
+              const double t1519 = t1193*t528;
+              const double t1520 = t792*t653;
+              const double t1521 = -t505*t72+t1500-t1501+t1502-t1503-t1505+t1507-t1508-t1386*t1509-t1511-t1513-t1515+t1517-t1518+t1519-t1520;
+              const double t1523 = t302*vertices[4](2);
+              const double t1524 = t1365*t1523;
+              const double t1526 = 2.0*t792*t60;
+              const double t1528 = 2.0*t792*t65;
+              const double t1529 = vertices[0](1)*t340;
+              const double t1530 = t1529*zeta;
+              const double t1532 = t792*t16;
+              const double t1533 = t792*t69;
+              const double t1535 = 2.0*t792*t11;
+              const double t1536 = t292*t15;
+              const double t1538 = t792*t486;
+              const double t1539 = t792*vertices[0](1);
+              const double t1541 = 2.0*t1539*t1273;
+              const double t1542 = t1193*t520;
+              const double t1544 = 2.0*t1386*t57;
+              const double t1545 = t424*t417;
+              const double t1546 = t1379*t421;
+              const double t1548 = t1524+t1526-t1528+t1530*t702-t1532+t1533-t1535-t1536-t1530*t725+t1538+t1541-t1542-t1544-t1545+t1546-t367*t81;
+              const double t1549 = vertices[5](0)*vertices[2](2);
+              const double t1550 = t1549*zeta;
+              const double t1551 = t438*eta;
+              const double t1553 = 2.0*t1550*t1551;
+              const double t1554 = t650*t38;
+              const double t1555 = t1379*t115;
+              const double t1556 = t495*t687;
+              const double t1557 = t1379*t120;
+              const double t1561 = 2.0*t620*t42;
+              const double t1562 = t366*zeta;
+              const double t1564 = t363*vertices[5](2);
+              const double t1565 = t638*t1564;
+              const double t1566 = t638*t1146;
+              const double t1567 = t330*t30;
+              const double t1568 = 2.0*t1567;
+              const double t1569 = t330*t687;
+              const double t1570 = 2.0*t1569;
+              const double t1571 = t620*t57;
+              const double t1572 = t620*t11;
+              const double t1573 = t620*t65;
+              const double t1575 = 2.0*t620*t16;
+              const double t1576 = -t1553-t1554+t1555-t1556-t1557-t1407*t490+t1407*t493-t1561-t1562*t526+t1565-t1566+t1568+t1570+t1571-t1572-t1573-t1575;
+              const double t1580 = t330*t5;
+              const double t1581 = t330*t8;
+              const double t1582 = t674*t1293;
+              const double t1584 = 2.0*t330*t508;
+              const double t1585 = t674*t343;
+              const double t1586 = t324*t517;
+              const double t1588 = t638*t661;
+              const double t1590 = 2.0*t792*t13;
+              const double t1591 = t323*t324;
+              const double t1593 = 2.0*t324*t562;
+              const double t1594 = t792*t106;
+              const double t1596 = t792*t108;
+              const double t1598 = t792*t115;
+              const double t1600 = 2.0*t792*t117;
+              const double t1602 = 2.0*t638*t477;
+              const double t1603 = -t1562*t545-t1580-t1581+t1582-t1584-t1585-3.0*t1586-t1588-t1590-t1591+t1593+3.0*t1594+3.0*t1596-t1598-t1600+t1602;
+              const double t1604 = t958*t198;
+              const double t1606 = t358*t438;
+              const double t1607 = 2.0*t1606;
+              const double t1608 = t638*t591;
+              const double t1609 = t1162*vertices[2](2);
+              const double t1610 = t792*t1609;
+              const double t1611 = t792*t1509;
+              const double t1612 = t620*t13;
+              const double t1613 = t334*t162;
+              const double t1614 = t358*t51;
+              const double t1615 = t476*t1564;
+              const double t1616 = t620*t106;
+              const double t1619 = 2.0*t620*t103;
+              const double t1622 = 2.0*t358*t614;
+              const double t1624 = 2.0*t1227*t353;
+              const double t1625 = t324*t465;
+              const double t1626 = t1604+t1562*t547-t1607-t1608-t1610+t1611-t1612+t1613+t1614-t1615+3.0*t1616-t1619+t1035*t84+t1622+t1624-t1625;
+              const double t1628 = t358*t499;
+              const double t1629 = 2.0*t1628;
+              const double t1630 = t620*t1509;
+              const double t1632 = t620*t1609;
+              const double t1633 = t476*t1146;
+              const double t1634 = t620*t653;
+              const double t1635 = vertices[5](0)*vertices[1](1);
+              const double t1636 = t1635*t162;
+              const double t1637 = t620*t486;
+              const double t1638 = t328*t1564;
+              const double t1639 = t736*vertices[5](1);
+              const double t1641 = t824*t1030;
+              const double t1643 = t739*t489;
+              const double t1645 = t614*vertices[3](2);
+              const double t1646 = t1379*t1645;
+              const double t1647 = t739*t417;
+              const double t1648 = -t1629+t1630-t1258*t304-t1632+t1633-t1634+t1636+t1637-t1638+t1639*t636-t1641+t1386*t653+t1643-t1386*t486+t1646-t1647;
+              const double t1649 = t328*t1146;
+              const double t1650 = t328*t304;
+              const double t1651 = t334*t206;
+              const double t1652 = 2.0*t1651;
+              const double t1653 = t412*vertices[5](1);
+              const double t1655 = 2.0*t1653*t747;
+              const double t1656 = t252*t469;
+              const double t1657 = t1379*zeta;
+              const double t1659 = t1193*t1434;
+              const double t1661 = t923*t210;
+              const double t1663 = t358*t520;
+              const double t1665 = 2.0*t1653*t669;
+              const double t1666 = t328*t307;
+              const double t1668 = t429*vertices[3](2);
+              const double t1669 = t156*t1668;
+              const double t1670 = t323*t499;
+              const double t1671 = t765*t490;
+              const double t1672 = t1649-t1650-t1652-t1655+t1656+t1657*t1064-t1659-t1657*t421-t1661-t1657*t115+t1663+t1665+t1666+t1657*t120-t1669+t1670+t1671;
+              const double t1677 = t765*t493;
+              const double t1678 = t595*t490;
+              const double t1679 = t595*t493;
+              const double t1680 = t792*vertices[2](1);
+              const double t1683 = t733*zeta;
+              const double t1685 = t1529*t517;
+              const double t1686 = t309*t179;
+              const double t1688 = 2.0*t1683*t692;
+              const double t1690 = t469*t1150;
+              const double t1692 = t469*t165;
+              const double t1694 = t5*vertices[7](2);
+              const double t1695 = t730*t1694;
+              const double t1697 = -t1677-t1678+t1679+t1680*t1146-t708*t304-t1683*t502-t1685+t1686+t1688+t1683*t636-t1690+t751*t502-t1692+t1530*t517-t1695-t751*t636;
+              const double t1698 = t1529*t702;
+              const double t1699 = t469*t1167;
+              const double t1700 = t469*t176;
+              const double t1701 = t768*eta;
+              const double t1703 = t1529*t725;
+              const double t1704 = t469*t179;
+              const double t1705 = t18*t509;
+              const double t1706 = t730*t13;
+              const double t1707 = t674*t10;
+              const double t1709 = vertices[3](0)*t340;
+              const double t1710 = t1709*vertices[0](1);
+              const double t1711 = t252*t1710;
+              const double t1713 = t730*t81;
+              const double t1714 = t328*t917;
+              const double t1715 = t730*t506;
+              const double t1717 = -t1698+t1699-t1700+t1701*t304+t1703-t1704+t1705+t1706-t1707-t433*t81+t1711-t969*t1046-t1713+t1714+t1715+t969*t967;
+              const double t1720 = t730*t110;
+              const double t1721 = t979*vertices[7](1);
+              const double t1722 = t739*t1721;
+              const double t1723 = t447*t162;
+              const double t1724 = t674*t106;
+              const double t1725 = t768*t477;
+              const double t1726 = t836*vertices[4](1);
+              const double t1727 = t252*t1726;
+              const double t1728 = t1562*t89;
+              const double t1730 = t441*t747;
+              const double t1731 = t765*t477;
+              const double t1733 = 2.0*t233*t751;
+              const double t1734 = t417*eta;
+              const double t1735 = t739*t1734;
+              const double t1736 = t309*t692;
+              const double t1737 = t358*t528;
+              const double t1738 = t1365*t1564;
+              const double t1739 = t733*t502;
+              const double t1740 = t433*t89-t1720+t1722-t1723-t1724-t1725+t1727-4.0*t1728-t1730+t1731+t1733+t1735-t1736-t1737+t1738+t1739;
+              const double t1741 = t328*t1523;
+              const double t1743 = 2.0*t1562*t92;
+              const double t1744 = t733*t636;
+              const double t1745 = t733*t692;
+              const double t1746 = t1365*t1146;
+              const double t1749 = t730*zeta;
+              const double t1751 = t469*t502;
+              const double t1753 = t469*t636;
+              const double t1754 = t1365*t304;
+              const double t1755 = t447*t179;
+              const double t1756 = t252*t970;
+              const double t1758 = t1379*t1064;
+              const double t1759 = -t1741+t1743-t1744-t1745-t1746-t1418*t493+t1386*t1609+t1749*t110-t1751-t1749*t506+t1753+t1754-t1755+t1756+t1749*t1694-t1758;
+              const double t1763 = t1365*t297;
+              const double t1766 = 2.0*t1539*t311;
+              const double t1768 = 2.0*t252*t1734;
+              const double t1769 = t1365*t917;
+              const double t1770 = t1365*t307;
+              const double t1771 = t679*t437;
+              const double t1772 = vertices[4](0)*vertices[7](2);
+              const double t1773 = t377*t1772;
+              const double t1774 = vertices[1](0)*vertices[2](1);
+              const double t1775 = t1774*t162;
+              const double t1776 = t727*t105;
+              const double t1777 = t727*t10;
+              const double t1778 = t727*t342;
+              const double t1779 = t366*t128;
+              const double t1780 = t1379*t105;
+              const double t1781 = t1379*t35;
+              const double t1782 = -t1749*t13-t1763+t367*t667-t1766-t1768-t1769-t1770-t1771+t1773+t1775-t1776+t1777-t1778-t1779+t1780+t1781;
+              const double t1783 = t568*eta;
+              const double t1785 = vertices[2](0)*t302;
+              const double t1786 = t1785*vertices[1](2);
+              const double t1787 = t156*t1786;
+              const double t1788 = t1379*t114;
+              const double t1789 = t377*t1027;
+              const double t1790 = t1379*t44;
+              const double t1791 = t1379*t342;
+              const double t1792 = t1379*t91;
+              const double t1793 = t443*t887;
+              const double t1794 = t864*zeta;
+              const double t1796 = t443*t1202;
+              const double t1797 = t443*t444;
+              const double t1799 = 2.0*t1783*t297;
+              const double t1800 = t447*t490;
+              const double t1801 = t1529*t623;
+              const double t1802 = t447*t493;
+              const double t1803 = t447*t502;
+              const double t1804 = -t1783*t304+t1787-t1788-t1789-t1790-t1791+t1792+t1793+t1794*t1146-t1796-t1797+t1799+t1800+t1801-t1802-t1803;
+              const double t1806 = t447*t636;
+              const double t1808 = t447*t531;
+              const double t1810 = t1379*t386;
+              const double t1811 = t674*t105;
+              const double t1812 = t1635*t1167;
+              const double t1813 = t674*t342;
+              const double t1814 = t447*t747;
+              const double t1815 = t366*vertices[1](1);
+              const double t1817 = t733*t174;
+              const double t1819 = 2.0*t1815*t297;
+              const double t1820 = vertices[1](1)*vertices[6](0);
+              const double t1821 = t1820*t477;
+              const double t1822 = t1635*t1150;
+              const double t1823 = t323*t364;
+              const double t1824 = t469*t210;
+              const double t1826 = 2.0*t447*t692;
+              const double t1827 = t1806+t1783*t307-3.0*t1808+t1810+t1811-t1812+t1813+t1814+t1815*t304-t1817-t1819+t1821+t1822+t1823+t1824+t1826;
+              const double t1830 = 2.0*t469*t174;
+              const double t1831 = t469*t168;
+              const double t1833 = t727*t35;
+              const double t1835 = 2.0*t469*t669;
+              const double t1836 = t595*t747;
+              const double t1837 = t443*t1027;
+              const double t1839 = 2.0*t595*t531;
+              const double t1840 = t309*t174;
+              const double t1841 = t595*t669;
+              const double t1842 = t733*t1150;
+              const double t1843 = t733*t1167;
+              const double t1846 = 2.0*t252*vertices[1](0)*t1551;
+              const double t1847 = t595*eta;
+              const double t1849 = 2.0*t1847*t747;
+              const double t1851 = t679*t444;
+              const double t1852 = -t1815*t307+t1830+t1831-t505*t42+t1833+t1835-t1836-t1837+t1839-t1840-t1841+t1842-t1843+t1846+t1849+t378*t826+t1851;
+              const double t1856 = t1774*t917;
+              const double t1857 = t1774*t1523;
+              const double t1859 = t765*eta;
+              const double t1861 = t432*t435;
+              const double t1863 = t736*t114;
+              const double t1864 = t366*t91;
+              const double t1865 = t736*t105;
+              const double t1866 = t377*t888;
+              const double t1867 = t447*t1150;
+              const double t1869 = 2.0*t483*t106;
+              const double t1871 = 2.0*t483*t110;
+              const double t1872 = t736*t10;
+              const double t1873 = t620*t10;
+              const double t1874 = t483*t1509;
+              const double t1875 = -t1856+t1857-t378*t1098-t1859*t490-t1861+t1859*t493-t1863+t1864+t1865+t1866-t1867-t1869+t1871-t1872+t1873-t1874;
+              const double t1876 = t412*vertices[4](2);
+              const double t1877 = t18*t1876;
+              const double t1878 = t18*t454;
+              const double t1879 = t432*t459;
+              const double t1881 = t792*t114;
+              const double t1882 = t483*t1609;
+              const double t1883 = t366*t36;
+              const double t1884 = t483*t486;
+              const double t1885 = vertices[2](0)*vertices[7](1);
+              const double t1886 = t1885*zeta;
+              const double t1888 = t412*vertices[0](2);
+              const double t1889 = t18*t1888;
+              const double t1890 = t330*t1162;
+              const double t1891 = t908*t174;
+              const double t1892 = t441*t210;
+              const double t1893 = 2.0*t1892;
+              const double t1895 = 2.0*t441*t212;
+              const double t1896 = t441*t174;
+              const double t1897 = 2.0*t1896;
+              const double t1898 = t425*t340;
+              const double t1900 = t1877+t1878+t1879-t1847*t493+t1881+t1882-t1883-t1884+t1886*t1564-t1889+t1890+t1891-t1893+t1895-t1897-t1898*t838;
+              const double t1902 = t979*vertices[4](2);
+              const double t1904 = 2.0*t18*t1902;
+              const double t1905 = t979*vertices[0](2);
+              const double t1907 = 2.0*t18*t1905;
+              const double t1908 = t441*t168;
+              const double t1909 = 2.0*t1908;
+              const double t1911 = t337*t165;
+              const double t1912 = t337*t174;
+              const double t1914 = 2.0*t337*t168;
+              const double t1915 = t483*t42;
+              const double t1916 = t483*t38;
+              const double t1917 = t337*t179;
+              const double t1918 = t650*t42;
+              const double t1919 = t908*t1150;
+              const double t1920 = t908*t1167;
+              const double t1922 = vertices[7](1)*vertices[2](2)*xi;
+              const double t1924 = t18*t517;
+              const double t1925 = t18*t623;
+              const double t1926 = -t1904+t1907-t1909+t1847*t490-t1911+t1912+t1914+t1915+t1916-t1917+t1918-t1919+t1920+t505*t1922-t1924+t1925;
+              const double t1927 = t18*t806;
+              const double t1930 = 2.0*t484*t106;
+              const double t1931 = t739*t638;
+              const double t1933 = t441*t1150;
+              const double t1934 = t441*t1167;
+              const double t1935 = t887*eta;
+              const double t1936 = t18*t1935;
+              const double t1937 = t1027*xi;
+              const double t1938 = t443*t1937;
+              const double t1939 = t18*t1164;
+              const double t1940 = t441*t179;
+              const double t1942 = 2.0*t300*t687;
+              const double t1943 = t441*t165;
+              const double t1944 = t864*t189;
+              const double t1945 = t123*vertices[0](2);
+              const double t1946 = t1820*t1945;
+              const double t1947 = t908*t162;
+              const double t1948 = t739*t980;
+              const double t1949 = -t1927+t1898*t42+t1930-t1931-t505*t459+t1933-t1934+t1936+t1938-t1939+t1940-t1942+t1943+t1944-t1946-t1947-t1948;
+              const double t1952 = t449*eta;
+              const double t1955 = 2.0*t360*t189;
+              const double t1956 = t679*t1027;
+              const double t1958 = 2.0*t292*t30;
+              const double t1959 = t337*t196;
+              const double t1961 = t864*t212;
+              const double t1962 = t864*t187;
+              const double t1964 = t441*t162;
+              const double t1966 = t1774*t297;
+              const double t1968 = t324*t300;
+              const double t1970 = t499*t437;
+              const double t1971 = t1952*t1001-t1955+t1956-t1958+t1959-t1952*t96-t1961-t1962-t1952*t506+t1964-t1111*t396-t1966-t351*t1937-t1968+t1111*t398+t1970;
+              const double t1973 = 2.0*t756*t661;
+              const double t1975 = 2.0*t349*t465;
+              const double t1976 = vertices[4](0)*t302;
+              const double t1977 = t1976*vertices[1](2);
+              const double t1978 = t18*t1977;
+              const double t1980 = 2.0*t252*t1244;
+              const double t1981 = t309*t204;
+              const double t1984 = 2.0*t756*t477;
+              const double t1986 = 2.0*t337*t345;
+              const double t1987 = t727*eta;
+              const double t1989 = t252*t1847;
+              const double t1990 = vertices[5](0)*t302;
+              const double t1991 = t1990*vertices[0](2);
+              const double t1992 = t18*t1991;
+              const double t1993 = t334*t917;
+              const double t1995 = t334*t1523;
+              const double t1996 = t958*t917;
+              const double t1997 = t1976*vertices[0](2);
+              const double t1998 = t18*t1997;
+              const double t1999 = t1973+t1975+t1978+t1980-t1981+t969*t384-t1984+t1986+t1987*t84-t1989+t1992-t1993+t1657*t838+t1995+t1996-t1998;
+              const double t2001 = t958*t1523;
+              const double t2002 = t679*t1937;
+              const double t2003 = t650*t1922;
+              const double t2004 = t779*t69;
+              const double t2005 = t779*t45;
+              const double t2006 = t923*t212;
+              const double t2007 = t779*t110;
+              const double t2008 = t650*t459;
+              const double t2009 = t779*t13;
+              const double t2010 = t1635*t174;
+              const double t2011 = t349*zeta;
+              const double t2013 = 2.0*t2011*t465;
+              const double t2014 = t1379*t106;
+              const double t2016 = 2.0*t292*t59;
+              const double t2017 = t292*t51;
+              const double t2018 = t414*vertices[3](2);
+              const double t2020 = t768*t198;
+              const double t2021 = -t2001-t2002-t2003-t2004+t2005+t2006+t2007+t2008+t2009-t2010-t2013-t2014+t2016-t2017+t1562*t2018+t2020;
+              const double t2022 = t425*eta;
+              const double t2023 = t2022*t72;
+              const double t2025 = t358*t59;
+              const double t2026 = 2.0*t2025;
+              const double t2027 = t360*t187;
+              const double t2028 = 2.0*t2027;
+              const double t2029 = t360*t204;
+              const double t2030 = t230*t417;
+              const double t2032 = 2.0*t779*t106;
+              const double t2033 = t377*t850;
+              const double t2034 = t360*t196;
+              const double t2035 = t377*t840;
+              const double t2036 = t360*t198;
+              const double t2037 = 2.0*t2036;
+              const double t2038 = t360*t206;
+              const double t2039 = 2.0*t2038;
+              const double t2040 = t779*t108;
+              const double t2041 = t377*t848;
+              const double t2042 = t360*t162;
+              const double t2044 = 2.0*t2022*t74;
+              const double t2045 = t779*t1509;
+              const double t2046 = t447*t165;
+              const double t2047 = -4.0*t2023-t2026+t2028-t2029+t2030-t2032-t2033-t2034+t2035+t2037+t2039-t2040-t2041-t2042+t2044-t2045-t2046;
+              const double t2054 = t779*t653;
+              const double t2055 = t779*t1609;
+              const double t2056 = t447*t174;
+              const double t2057 = 2.0*t2056;
+              const double t2059 = 2.0*t514*t692;
+              const double t2060 = t290*t11;
+              const double t2061 = t377*t857;
+              const double t2062 = t1774*t198;
+              const double t2064 = 2.0*t484*t110;
+              const double t2065 = t779*t486;
+              const double t2066 = t679*t887;
+              const double t2067 = t736*t25;
+              const double t2068 = t727*t78;
+              const double t2069 = t727*t83;
+              const double t2070 = t620*t25;
+              const double t2071 = t349*t870;
+              const double t2073 = t2054+t2055+t2057+t2059+t2060+t2061-t2062-t2064-t2065-t2066+t2067-t2068+t2069-t2070+t2071+t484*t1509;
+              const double t2075 = 2.0*t2011*t623;
+              const double t2076 = t1379*t83;
+              const double t2077 = t679*t1202;
+              const double t2079 = 2.0*t792*t25;
+              const double t2083 = t449*t1001;
+              const double t2084 = t674*t78;
+              const double t2085 = t674*t83;
+              const double t2086 = t595*t210;
+              const double t2087 = t309*t198;
+              const double t2088 = t479*t469;
+              const double t2089 = t349*t875;
+              const double t2090 = t586*t917;
+              const double t2091 = t586*t1523;
+              const double t2092 = t2075-t2076+t2077-t2079-t484*t653-t484*t1609+t394*t1076-t2083+t2084-t2085-t2086+t2087+t2088-t2089-t2090+t2091;
+              const double t2094 = t349*t1027;
+              const double t2095 = 2.0*t2094;
+              const double t2096 = t768*t917;
+              const double t2098 = 2.0*t1232*t669;
+              const double t2099 = t768*t1523;
+              const double t2101 = 2.0*t1847*t531;
+              const double t2102 = t449*t96;
+              const double t2104 = 2.0*t2011*t562;
+              const double t2105 = t586*t187;
+              const double t2106 = t586*t204;
+              const double t2108 = t586*t196;
+              const double t2110 = 2.0*t708*t297;
+              const double t2111 = t360*t1523;
+              const double t2112 = t860*t687;
+              const double t2114 = 2.0*t349*t562;
+              const double t2115 = t736*t340;
+              const double t2117 = t2095+t2096-t2098-t2099-t2101+t2102+t2104-t2105+t2106+t1952*t72+t2108+t2110-t2111+t2112-t2114+t2115*t961;
+              const double t2119 = t736*t419;
+              const double t2120 = t736*t415;
+              const double t2123 = 2.0*t349*t467;
+              const double t2124 = t736*vertices[6](1);
+              const double t2127 = t485*vertices[1](2);
+              const double t2129 = t377*t826;
+              const double t2130 = t363*vertices[0](2);
+              const double t2132 = t363*vertices[1](2);
+              const double t2135 = t377*t1098;
+              const double t2136 = t377*t444;
+              const double t2138 = 2.0*t349*t610;
+              const double t2140 = -t2115*t106-t2119+t2120-t1987*t368-t2123-t2124*t1564+t2124*t1146-t2022*t2127-t2129-t2124*t2130+t2124*t2132+t1987*t371+t2135+t2136+t2138+t1987*t13;
+              const double t2145 = t437*xi;
+              const double t2146 = t349*t2145;
+              const double t2147 = t362*t325;
+              const double t2148 = t1252*t1564;
+              const double t2150 = t449*t72;
+              const double t2151 = t1252*t1146;
+              const double t2152 = t360*t1564;
+              const double t2153 = t360*t1146;
+              const double t2155 = 2.0*t756*t1945;
+              const double t2161 = -t1987*t57+t2115*t343+t2146-t2147-t2148+t1987*t1064-t2150+t2151-t2152+t2153+t2155-t394*t569-t969*t997-t756*t1564-t1111*t497+t756*t1146;
+              const double t2162 = t156*t300;
+              const double t2166 = t156*t1202;
+              const double t2168 = t824*t454;
+              const double t2170 = t736*vertices[3](1);
+              const double t2172 = 2.0*t2170*t477;
+              const double t2173 = t727*t1050;
+              const double t2176 = 2.0*t2170*t591;
+              const double t2177 = t437*t15;
+              const double t2179 = t362*t123*vertices[0](1);
+              const double t2181 = 2.0*t2170*t1945;
+              const double t2183 = 2.0*t736*t76;
+              const double t2184 = -t2162+t1111*t576+t756*t2132-t756*t2130-t2166-t704*t1152-t2168-t2115*t387-t2172+t2173-t2115*t459-t2176-t2177+t2179+t2181+t2183;
+              const double t2186 = t736*t81;
+              const double t2187 = t736*eta;
+              const double t2189 = 2.0*t2187*t72;
+              const double t2190 = t736*t84;
+              const double t2192 = 2.0*t828*t106;
+              const double t2194 = t736*t89;
+              const double t2195 = t230*t469;
+              const double t2196 = t736*t92;
+              const double t2197 = t727*t81;
+              const double t2198 = t727*t667;
+              const double t2201 = 2.0*t620*t26;
+              const double t2202 = t586*t206;
+              const double t2203 = t727*t84;
+              const double t2204 = t360*t304;
+              const double t2205 = t360*t307;
+              const double t2206 = -t2186+t2189+t2190+t2192+t1035*t459+t2194+t2195-t2196+t2197-t2198+t1987*t65+t2201-t2202-t2203-t2204+t2205;
+              const double t2207 = t917*zeta;
+              const double t2208 = t360*t2207;
+              const double t2210 = t1523*zeta;
+              const double t2211 = t360*t2210;
+              const double t2212 = t360*t661;
+              const double t2213 = t360*t477;
+              const double t2216 = 2.0*t360*t1945;
+              const double t2218 = 2.0*t360*t297;
+              const double t2219 = t425*t72;
+              const double t2221 = t1774*t1564;
+              const double t2222 = t1774*t1146;
+              const double t2223 = t196*zeta;
+              const double t2225 = 2.0*t360*t2223;
+              const double t2227 = 2.0*t586*t198;
+              const double t2229 = 2.0*t425*t74;
+              const double t2230 = t349*t1082;
+              const double t2231 = t360*t976;
+              const double t2233 = t360*t345;
+              const double t2235 = -t2208-t1987*t74+t2211+t2212-3.0*t2213+t2216+t2218+3.0*t2219+t2221-t2222+t2225-t2227-t2229-t2230-t2231-t1171*t120-3.0*t2233;
+              const double t2239 = vertices[5](0)*vertices[7](1);
+              const double t2240 = t2239*eta;
+              const double t2242 = 2.0*t2240*t1255;
+              const double t2243 = t349*t623;
+              const double t2244 = t736*t551;
+              const double t2245 = t736*t557;
+              const double t2247 = t51*vertices[3](2);
+              const double t2248 = t727*t2247;
+              const double t2249 = t349*t510;
+              const double t2251 = t355*vertices[1](2);
+              const double t2253 = t792*t96;
+              const double t2254 = t674*t1050;
+              const double t2256 = 2.0*t1815*t747;
+              const double t2257 = t674*t81;
+              const double t2258 = t674*t667;
+              const double t2259 = t674*t84;
+              const double t2261 = 2.0*t469*t692;
+              const double t2262 = t469*t1180;
+              const double t2263 = t2242-t2243-t2244+t2245-t2240*t493-t2248+3.0*t2249-t853*t2251+t2253-t2254-t2256-t2257+t2258+t2259+t2261-t2262;
+              const double t2264 = t727*t112;
+              const double t2265 = t1252*zeta;
+              const double t2268 = t453*t465;
+              const double t2270 = 2.0*t453*t623;
+              const double t2272 = 2.0*t1734*t297;
+              const double t2273 = t792*vertices[3](1);
+              const double t2277 = 2.0*t2273*t661;
+              const double t2278 = t453*t1876;
+              const double t2279 = t2273*t477;
+              const double t2281 = t620*t783;
+              const double t2284 = 2.0*t2273*t1945;
+              const double t2285 = t453*t1902;
+              const double t2287 = t366*t2018;
+              const double t2288 = -t2264-t2265*t1146+t2265*t1564+t2268-t2270-t2272-t2273*t1146+t2273*t1564-t2277-t2278+4.0*t2279-t2281-t1680*t1564-t2284+3.0*t2285-t2287;
+              const double t2290 = t508*vertices[4](2);
+              const double t2291 = t727*t2290;
+              const double t2292 = t360*eta;
+              const double t2294 = 2.0*t2292*t297;
+              const double t2295 = t550*vertices[2](2);
+              const double t2297 = t792*t529;
+              const double t2299 = 2.0*t1734*t2223;
+              const double t2301 = t792*t540;
+              const double t2303 = t1379*t86;
+              const double t2304 = t550*vertices[3](2);
+              const double t2307 = t453*t562;
+              const double t2310 = t366*t521;
+              const double t2311 = t620*t798;
+              const double t2312 = t2291-t2294-t413*t2295+t2297+t2299-t1657*t84-t2301+t1657*t92+t2303-t1562*t2304+t560*t2018-t2307-t1478*t84+t1478*t81-t2310+t2311;
+              const double t2315 = t366*t526;
+              const double t2317 = 2.0*t413*t65;
+              const double t2320 = t1379*t92;
+              const double t2321 = t1379*t84;
+              const double t2323 = 2.0*t2170*t661;
+              const double t2324 = t366*t545;
+              const double t2325 = t366*t547;
+              const double t2327 = t341*t500;
+              const double t2328 = t586*t1146;
+              const double t2329 = vertices[4](1)*t340;
+              const double t2330 = t2329*t702;
+              const double t2332 = t1478*t1050-t1478*t667+t2315+t2317+t2292*t304-t2292*t307-t2320+t2321+t2323+t2324-t2325+t2115*t435+t2327-t2328+t2330+t1318*t1564;
+              const double t2338 = 2.0*t595*t477;
+              const double t2339 = t1193*t438;
+              const double t2340 = t377*t1030;
+              const double t2342 = 2.0*t1318*t661;
+              const double t2343 = t432*t81;
+              const double t2345 = 2.0*t1318*t477;
+              const double t2346 = t730*t459;
+              const double t2347 = t730*t435;
+              const double t2348 = t483*t72;
+              const double t2349 = t432*t89;
+              const double t2351 = 2.0*t751*t692;
+              const double t2352 = t650*t1001;
+              const double t2353 = t650*t506;
+              const double t2354 = t650*t96;
+              const double t2355 = -t394*t766-t1318*t1146-t2338+t2339+t2340-t2342+t2343+t2345-t2346+t2347-t2348-t2349-t2351+t2352-t2353-t2354;
+              const double t2358 = t650*t72;
+              const double t2359 = t230*t586;
+              const double t2361 = 2.0*t1701*t297;
+              const double t2363 = vertices[3](1)*t340;
+              const double t2364 = t2363*vertices[4](2);
+              const double t2365 = t736*t2364;
+              const double t2366 = t309*eta;
+              const double t2368 = 2.0*t2366*t345;
+              const double t2369 = t233*zeta;
+              const double t2371 = 2.0*t2369*t734;
+              const double t2374 = 2.0*t2369*t576;
+              const double t2376 = t483*t128;
+              const double t2377 = t768*t304;
+              const double t2378 = t366*t79;
+              const double t2379 = t727*t76;
+              const double t2380 = -t2115*t92+t2115*t89+t2358-t2359-t2361-t1701*t307-t2365+t2368+t2371+t1749*t459+t2374-t1749*t435+t2376-t2377+t2378-t2379;
+              const double t2382 = t366*t81;
+              const double t2383 = t768*t307;
+              const double t2385 = 2.0*t309*t345;
+              const double t2386 = t765*t531;
+              const double t2388 = t59*vertices[7](2);
+              const double t2389 = t727*t2388;
+              const double t2390 = t453*t1030;
+              const double t2391 = t595*t1564;
+              const double t2392 = t595*t1146;
+              const double t2394 = t595*t591;
+              const double t2395 = t366*t89;
+              const double t2399 = 2.0*t330*t601;
+              const double t2400 = t586*t176;
+              const double t2401 = t330*t817;
+              const double t2402 = -t2382+t2383-t2385-t2386-t1987*t1050+t2389-t2390-t2391+t2392-t505*t1001+t2394+3.0*t2395+t505*t96+t2399+t2400-t2401;
+              const double t2403 = t792*t76;
+              const double t2406 = t792*t92;
+              const double t2409 = 2.0*t366*t92;
+              const double t2410 = t779*t540;
+              const double t2411 = t923*t1255;
+              const double t2412 = t437*t528;
+              const double t2413 = t739*t766;
+              const double t2418 = 2.0*t323*t1194;
+              const double t2419 = t377*t300;
+              const double t2420 = t586*t1564;
+              const double t2421 = t1820*t490;
+              const double t2423 = -3.0*t2403+t1987*t667+t2406-t1987*t81-t2409+t2410-t2411+t2412+t2413-t1244*t304+t1244*t307+t950*t1050-t2418-t2419+t2420+t2421-t2022*t551;
+              const double t2429 = t1820*t493;
+              const double t2431 = t1635*t490;
+              const double t2432 = t449*t506;
+              const double t2434 = 2.0*t756*t591;
+              const double t2437 = 2.0*t586*t297;
+              const double t2439 = 2.0*t586*t345;
+              const double t2440 = t586*t2223;
+              const double t2441 = t679*t2145;
+              const double t2443 = 2.0*t1680*t1273;
+              const double t2446 = 2.0*t447*t1255;
+              const double t2449 = t1562*t521-t2429+t708*t307-t2431+t2432-t2434+t2022*t557-t2437+t2439-t2440+t2441-t2443+t1749*t81+t2446+t2022*t415-t2022*t419;
+              const double t2450 = t597*eta;
+              const double t2451 = t358*t2450;
+              const double t2453 = t616*eta;
+              const double t2454 = t358*t2453;
+              const double t2456 = t1635*t493;
+              const double t2457 = t425*t2290;
+              const double t2458 = t586*t307;
+              const double t2459 = t586*t304;
+              const double t2461 = t586*t2207;
+              const double t2462 = t586*t2210;
+              const double t2463 = t1635*t502;
+              const double t2464 = t1635*t692;
+              const double t2466 = 2.0*t586*t477;
+              const double t2468 = t377*t509;
+              const double t2469 = t2451-t1749*t89-t2454-t1987*t421+t2456-t2457-t2458+t2459-t2115*t81+t2461-t2462+t2463-t2464+t2466+t1734*t304+t2468;
+              const double t2472 = t1635*t636;
+              const double t2474 = 2.0*t586*t591;
+              const double t2475 = t768*t1564;
+              const double t2476 = t292*t817;
+              const double t2477 = t765*t1146;
+              const double t2478 = t765*t1564;
+              const double t2480 = t191*vertices[4](2);
+              const double t2482 = t390*zeta;
+              const double t2485 = t499*eta;
+              const double t2487 = 2.0*t2485*t610;
+              const double t2489 = t393*t1076;
+              const double t2492 = -t1734*t307-t2472-t2474-t2475+t2476-t2477+t2478+t394*t769-t1657*t2480+t2482*t1564+t1657*t371+t2487-t1478*t11-t2489-t1447*t502-t1530*t623;
+              const double t2494 = t736*vertices[1](1);
+              const double t2497 = 2.0*t2494*t692;
+              const double t2500 = t1990*vertices[1](2);
+              const double t2501 = t18*t2500;
+              const double t2503 = 2.0*t2494*t1273;
+              const double t2504 = t727*t11;
+              const double t2505 = t736*t2127;
+              const double t2507 = t485*vertices[0](2);
+              const double t2508 = t736*t2507;
+              const double t2510 = 2.0*t1639*t692;
+              const double t2513 = 2.0*t1639*t1273;
+              const double t2514 = t908*t502;
+              const double t2515 = t908*t692;
+              const double t2516 = t1447*t636-t2494*t636-t2497+t2494*t502-t2482*t1146-t2501+t2503-t2504-t2505-t1639*t502+t2508+t2510-t378*t1030-t2513-t2514+t2515;
+              const double t2519 = t489*t636;
+              const double t2521 = t908*t636;
+              const double t2522 = t441*t502;
+              const double t2523 = t923*t490;
+              const double t2524 = t441*t636;
+              const double t2526 = 2.0*t1774*t477;
+              const double t2527 = t768*zeta;
+              const double t2529 = t1252*t1945;
+              const double t2530 = t309*t1180;
+              const double t2531 = t290*t931;
+              const double t2532 = t779*t89;
+              const double t2534 = 2.0*t309*t311;
+              const double t2535 = t233*t926;
+              const double t2536 = t765*zeta;
+              const double t2539 = -t2519-t2482*t2132+t2521+t2522-t2523-t2524+t2526+t2527*t1564+t2529+t2530-t2531-t2532-t2534-t2535-t2536*t1564+t2536*t1146;
+              const double t2541 = t893*t610;
+              const double t2543 = 2.0*t1140*t477;
+              const double t2547 = 2.0*t638*t531;
+              const double t2549 = 2.0*t1140*t591;
+              const double t2550 = t230*t489;
+              const double t2551 = t362*t474;
+              const double t2555 = t779*t76;
+              const double t2556 = t290*t2018;
+              const double t2557 = t290*t2295;
+              const double t2558 = t483*t79;
+              const double t2559 = -t1140*t1564-t2541-t2543+t1140*t1146+t2482*t2130-t2547+t2549-t2550+t2551-t580*t371+t2115*t84-t2527*t1146+t2555+t2556+t2557-t2558;
+              const double t2562 = 2.0*t923*t531;
+              const double t2563 = t923*t493;
+              const double t2564 = t18*xi;
+              const double t2565 = t323*t2564;
+              const double t2566 = t341*t42;
+              const double t2567 = t923*t747;
+              const double t2570 = 2.0*t1244*t297;
+              const double t2572 = 2.0*t400*t345;
+              const double t2573 = t779*t529;
+              const double t2574 = t324*vertices[0](2);
+              const double t2575 = t736*t2574;
+              const double t2576 = t782*eta;
+              const double t2583 = t2562+t2563+t2565-t2566-t2567+t400*t304+t2570+t2572-t2573+t2575-t2576*t610-t2115*t110+t2115*t506+t2187*t2127+t1987*t11-t2187*t2507;
+              const double t2584 = t334*zeta;
+              const double t2587 = 2.0*t2584*t692;
+              const double t2588 = t736*t2290;
+              const double t2589 = t499*t610;
+              const double t2590 = t425*t2507;
+              const double t2591 = t425*t2127;
+              const double t2593 = t383*zeta;
+              const double t2596 = 2.0*t2593*t692;
+              const double t2598 = t425*t2574;
+              const double t2601 = 2.0*t590*t477;
+              const double t2604 = t432*t1694;
+              const double t2606 = -t2584*t502+t2587-t2588-t2589-t2590+t2591+t2584*t636+t2593*t502-t2596-t2593*t636+t2598+t2022*t2507+t2601-t426*t636+t426*t502+t2604-t1898*t96;
+              const double t2610 = t824*t1772;
+              const double t2611 = t432*t13;
+              const double t2615 = t499*t806;
+              const double t2617 = t432*t506;
+              const double t2618 = t425*t10;
+              const double t2619 = t1075*eta;
+              const double t2620 = t355*vertices[0](2);
+              const double t2622 = t432*t110;
+              const double t2623 = t1252*t477;
+              const double t2624 = t323*t614;
+              const double t2625 = t425*t551;
+              const double t2626 = t366*t2295;
+              const double t2627 = t366*t2304;
+              const double t2629 = 2.0*t499*t2145;
+              const double t2630 = -t2610-t2611+t1898*t16-t1898*t371+t1898*t2480+3.0*t2615-t2617-t2618-t2619*t2620+t2622-t2623-t2624+t2625-t2626+t2627-t2629;
+              const double t2631 = t444*t499;
+              const double t2632 = t425*t557;
+              const double t2633 = t739*t1232;
+              const double t2634 = t393*t766;
+              const double t2635 = t499*t1030;
+              const double t2637 = 2.0*t1680*t477;
+              const double t2640 = 2.0*t233*vertices[5](0)*t1197;
+              const double t2641 = t393*t569;
+              const double t2642 = t425*t415;
+              const double t2643 = t499*t2500;
+              const double t2644 = t674*t11;
+              const double t2646 = 2.0*t909*t692;
+              const double t2647 = t499*t1997;
+              const double t2648 = t441*zeta;
+              const double t2651 = t499*t1991;
+              const double t2652 = -t2631-t2632+t2633+t2634+t2635-t2637-t2640+t2641-t2642+t2643+t2644-t2646+t2647-t2648*t502-t909*t636-t2651;
+              const double t2655 = t1379*t96;
+              const double t2657 = t377*t887;
+              const double t2658 = t1379*t16;
+              const double t2659 = t499*t1977;
+              const double t2660 = t1379*t371;
+              const double t2661 = t1379*t2480;
+              const double t2662 = t736*vertices[4](1);
+              const double t2665 = t425*t419;
+              const double t2666 = t727*t106;
+              const double t2669 = t156*t437;
+              const double t2670 = t425*t25;
+              const double t2671 = t2648*t636-t2655+t1478*t106-t2657+t2658-t2659-t2660+t2661+t2662*t502-t2662*t636+t2665+t2666+t1657*t96-t1657*t16+t2669+t2670;
+              const double t2674 = t679*t1902;
+              const double t2677 = t1709*vertices[4](2);
+              const double t2678 = t18*t2677;
+              const double t2679 = t1709*vertices[0](2);
+              const double t2680 = t18*t2679;
+              const double t2682 = 2.0*t853*t747;
+              const double t2684 = 2.0*t853*t531;
+              const double t2687 = 2.0*t853*t669;
+              const double t2689 = 2.0*t853*t1255;
+              const double t2692 = t366*t13;
+              const double t2694 = t979*vertices[7](2);
+              const double t2695 = t679*t2694;
+              const double t2696 = -t2187*t415+t1478*t74+t2674-t1952*t1922-t1952*t38+t2678-t2680-t2682+t2684+t1952*t459+t2687-t2689+t2619*t490-t2619*t493+t2692+t2619*t2251-t2695;
+              const double t2699 = t824*t1027;
+              const double t2700 = t366*t110;
+              const double t2702 = t366*t120;
+              const double t2705 = 2.0*t366*t115;
+              const double t2708 = t18*eta;
+              const double t2710 = 2.0*t2708*t806;
+              const double t2713 = t730*vertices[7](2);
+              const double t2714 = t18*t2713;
+              const double t2717 = t464*vertices[7](2);
+              const double t2720 = t425*t16;
+              const double t2721 = t2699-3.0*t2700-t2702-t853*t490+t2705+t853*t493-t2115*t1694+t2710+t2115*t13-t1987*t106-t2714-t514*t502+t514*t636+t787*t2717+t2187*t419+t2720;
+              const double t2725 = 2.0*t2187*t65;
+              const double t2726 = t2363*vertices[0](2);
+              const double t2727 = t736*t2726;
+              const double t2728 = t290*t105;
+              const double t2729 = t727*t108;
+              const double t2730 = t443*t788;
+              const double t2731 = t727*t2574;
+              const double t2733 = t483*vertices[4](2);
+              const double t2734 = t679*t2733;
+              const double t2735 = t679*t1935;
+              const double t2736 = t2329*vertices[3](2);
+              const double t2737 = t736*t2736;
+              const double t2738 = t1529*vertices[3](2);
+              const double t2739 = t736*t2738;
+              const double t2740 = t1529*vertices[7](2);
+              const double t2741 = t736*t2740;
+              const double t2743 = t782*t806;
+              const double t2744 = t2576*t895+t1987*t1293-t2725+t2727+t2728+t2729-t2730-t2731-t1987*t343-t2734+t2735+t2737-t2739+t2741-t2187*t1440-t2743;
+              const double t2747 = t479*t391;
+              const double t2749 = t679*t1888;
+              const double t2750 = t499*t340;
+              const double t2754 = 2.0*t2187*t38;
+              const double t2755 = t292*zeta;
+              const double t2757 = 2.0*t2755*t314;
+              const double t2758 = t2329*vertices[7](2);
+              const double t2759 = t736*t2758;
+              const double t2760 = t679*t1098;
+              const double t2761 = t1213*vertices[0](2);
+              const double t2762 = t736*t2761;
+              const double t2763 = t1027*eta;
+              const double t2764 = t679*t2763;
+              const double t2766 = 2.0*t2187*t57;
+              const double t2767 = t366*vertices[0](2);
+              const double t2768 = t679*t2767;
+              const double t2770 = 2.0*t2022*t42;
+              const double t2772 = -t2115*t1064+t2747+t2187*t1450-t2749-t2750*t462+t2115*t115-t2754-t2757-t2759+t2760-t2762-t2764+t2766+t2768-t2770+t413*t2304;
+              const double t2774 = t727*t52;
+              const double t2775 = t1213*vertices[4](2);
+              const double t2776 = t736*t2775;
+              const double t2777 = t432*vertices[7](2);
+              const double t2778 = t18*t2777;
+              const double t2779 = t324*t353;
+              const double t2782 = t836*vertices[0](2);
+              const double t2783 = t18*t2782;
+              const double t2785 = t432*vertices[3](2);
+              const double t2786 = t18*t2785;
+              const double t2788 = t2329*t725;
+              const double t2791 = t425*t96;
+              const double t2792 = t2022*t38;
+              const double t2795 = t2750*t1030+t2774+t2776+t2778-t2779+t2022*t1440-t2022*t1450+t2783+t1898*t421-t2786-t885*t1301-t2788-t1898*t120+t1214*t462-t2791+4.0*t2792+t2576*t806;
+              const double t2801 = t2329*t623;
+              const double t2803 = 2.0*t2022*t11;
+              const double t2804 = t2329*t517;
+              const double t2805 = t449*t42;
+              const double t2807 = 2.0*t2022*t16;
+              const double t2808 = t449*t1922;
+              const double t2809 = t449*t38;
+              const double t2810 = t449*t459;
+              const double t2811 = t358*vertices[3](1);
+              const double t2813 = t425*t120;
+              const double t2816 = t324*t623;
+              const double t2817 = t366*t57;
+              const double t2819 = -t2801-t2803+t2804-t2805-t2807+t2808+t2809-t2810+t2811+t885*t1937-t2813+t853*t2620+t825*t1098+t2816-t2817+t2187*t551;
+              const double t2820 = t366*t65;
+              const double t2821 = t366*t16;
+              const double t2822 = t782*t610;
+              const double t2823 = t366*t67;
+              const double t2824 = t412*vertices[3](2);
+              const double t2825 = t679*t2824;
+              const double t2828 = 2.0*t2708*t353;
+              const double t2830 = t836*vertices[4](2);
+              const double t2831 = t18*t2830;
+              const double t2832 = t156*t509;
+              const double t2834 = t324*t1786;
+              const double t2838 = t479*t766;
+              const double t2839 = t2820+t2821+t2822+t2823+t2825+t1952*t42+t2828-t885*t2145-t2831+t2832-t2187*t557-t2834+t1657*t106+t700*t1206-t1657*t42-t2838;
+              const double t2841 = t1379*t838;
+              const double t2842 = t727*t368;
+              const double t2843 = t479*t734;
+              const double t2844 = t727*t371;
+              const double t2846 = t727*t13;
+              const double t2847 = t727*t57;
+              const double t2848 = t727*t1064;
+              const double t2850 = 2.0*t1886*t1945;
+              const double t2851 = t727*t421;
+              const double t2852 = t727*t65;
+              const double t2853 = vertices[4](0)*vertices[6](2);
+              const double t2854 = t2853*xi;
+              const double t2856 = t1785*vertices[0](2);
+              const double t2857 = t324*t2856;
+              const double t2859 = t727*t74;
+              const double t2861 = -t2841+t2842+t2843-t2844-t700*t1160-t2846+t2847-t2848-t2850+t2851-t2852+t2750*t2854+t2857-t700*t1164+t2859-t1886*t1146;
+              const double t2862 = t412*t1645;
+              const double t2866 = t824*t379;
+              const double t2868 = 2.0*t1886*t477;
+              const double t2870 = 2.0*t1886*t661;
+              const double t2873 = 2.0*t1886*t591;
+              const double t2874 = t887*xi;
+              const double t2876 = t736*t72;
+              const double t2882 = -t2862-t2750*t610-t1886*t2132+t1886*t2130+t2866+t2868-t2870-t2576*t725+t2873+t700*t2874-t2876-t885*t543+t700*t1937-t1657*t961+t382*t481-t382*t970;
+              const double t2885 = t443*t509;
+              const double t2889 = t864*t1564;
+              const double t2890 = t864*t1146;
+              const double t2891 = t864*t661;
+              const double t2893 = 2.0*t864*t477;
+              const double t2896 = 2.0*t2662*t1273;
+              const double t2898 = 2.0*t2662*t692;
+              const double t2900 = t1774*t307;
+              const double t2901 = t1252*t531;
+              const double t2902 = t508*t467;
+              const double t2903 = t1252*t1255;
+              const double t2904 = t2885-t885*t1098-t885*t1160-t382*t396+t2889-t2890-t2891+t2893+t382*t1055+t2896-t2898+t885*t647-t2900+t2901+t2902-t2903;
+              const double t2905 = t412*t31;
+              const double t2906 = t864*t1945;
+              const double t2907 = t1772*xi;
+              const double t2909 = t337*t297;
+              const double t2910 = t508*t806;
+              const double t2912 = 2.0*t441*t692;
+              const double t2913 = t337*t976;
+              const double t2914 = t1774*t304;
+              const double t2915 = t479*t384;
+              const double t2916 = t782*t895;
+              const double t2917 = t425*t1440;
+              const double t2919 = 2.0*t426*t692;
+              const double t2920 = t425*t1450;
+              const double t2922 = 2.0*t426*t311;
+              const double t2923 = t425*t38;
+              const double t2925 = t412*t103;
+              const double t2926 = t2905-t2906-t700*t2907-t2909-t2910-t2912+t2913+t2914-t2915-t2916-t2917-t2919+t2920+t2922-3.0*t2923-t2925;
+              const double t2928 = t425*t42;
+              const double t2929 = t782*t725;
+              const double t2930 = t425*t45;
+              const double t2931 = t499*t647;
+              const double t2932 = t425*t57;
+              const double t2933 = t425*t52;
+              const double t2934 = t425*t65;
+              const double t2936 = 2.0*t425*t11;
+              const double t2937 = t425*t69;
+              const double t2943 = t824*t380;
+              const double t2944 = t18*t2733;
+              const double t2945 = t2928+t2929-t2930+t2931-t2932-t2933+t2934+t2936+t2937-t721*t506-t560*t2127+t721*t110-t950*t11+t560*t2507-t2943+t2944;
+              const double t2946 = t559*t1645;
+              const double t2948 = t559*t31;
+              const double t2949 = t824*t445;
+              const double t2951 = t824*t510;
+              const double t2952 = t824*t562;
+              const double t2954 = t824*t444;
+              const double t2957 = t360*vertices[0](2);
+              const double t2962 = 2.0*t1794*t477;
+              const double t2964 = 2.0*t1794*t661;
+              const double t2965 = -t2946-t837*t16+t2948+t2949-t560*t2304+t2951-t2952+t885*t445-t2954-t413*t2018+t560*t2295+t2957+t413*t937-t413*t2507+t413*t2127-t2962+t2964;
+              const double t2969 = t453*t454;
+              const double t2970 = t324*t350;
+              const double t2972 = t730*vertices[3](2);
+              const double t2973 = t18*t2972;
+              const double t2974 = t674*t368;
+              const double t2975 = t674*t371;
+              const double t2976 = t674*t57;
+              const double t2977 = t674*t13;
+              const double t2978 = t395*vertices[3](2);
+              const double t2980 = t674*t1064;
+              const double t2982 = t674*t421;
+              const double t2983 = t674*t65;
+              const double t2987 = t674*t74;
+              const double t2988 = -t2969+t2970*t623+t2973-t2974+t2975-t2976+t2977+t885*t2978+t2980-t837*t2480-t2982+t2983-t2970*t353+t2970*t462-t1794*t1564-t2987;
+              const double t2989 = t1379*t42;
+              const double t2990 = t1774*eta;
+              const double t2993 = 2.0*t2648*t692;
+              const double t2994 = t620*t74;
+              const double t2997 = 2.0*t2990*t297;
+              const double t2998 = t2329*zeta;
+              const double t3001 = t1379*t343;
+              const double t3002 = t337*eta;
+              const double t3004 = 2.0*t3002*t345;
+              const double t3006 = t650*vertices[7](2);
+              const double t3007 = t140*t3006;
+              const double t3008 = t290*t10;
+              const double t3012 = t2989-t2990*t304+t2993+t2994-t700*t1176+t2997-t2998*t702+t2990*t307+t3001-t3004+t2998*t725-t3007-t3008+t1478*t368-t1478*t371-t1478*t13;
+              const double t3022 = t18*t2767;
+              const double t3024 = t739*t469;
+              const double t3026 = t620*t1119;
+              const double t3027 = t620*t1116;
+              const double t3028 = t437*t2453;
+              const double t3029 = t620*t128;
+              const double t3030 = t2998*t623-t1657*t343+t1478*t57-t1478*t1064-t2998*t517+t1478*t421+t700*t1178+t837*t371-t3022-t1478*t65-t3024+t1657*t387-t3026+t3027+t3028-t3029;
+              const double t3031 = vertices[3](0)*t302;
+              const double t3032 = t3031*vertices[0](2);
+              const double t3033 = t324*t3032;
+              const double t3034 = t3031*vertices[1](2);
+              const double t3035 = t324*t3034;
+              const double t3037 = 2.0*t18*t2763;
+              const double t3039 = 2.0*t413*t42;
+              const double t3041 = 2.0*t413*t13;
+              const double t3043 = 2.0*t413*t57;
+              const double t3045 = 2.0*t413*t106;
+              const double t3047 = 2.0*t413*t110;
+              const double t3049 = 2.0*t413*t115;
+              const double t3051 = 2.0*t413*t120;
+              const double t3053 = t679*t1160;
+              const double t3058 = t679*t647;
+              const double t3059 = -t3033+t3035+t3037+t3039+t3041-t3043-t3045-t3047+t3049-t3051-t413*t1509+t3053+t413*t1609+t825*t380+t825*t562-t825*t445-t3058;
+              const double t3064 = t1379*t387;
+              const double t3065 = t495*t1162;
+              const double t3070 = t1193*t2450;
+              const double t3074 = t18*t1160;
+              const double t3075 = t323*t945;
+              const double t3076 = t568*zeta;
+              const double t3078 = 2.0*t3076*t1273;
+              const double t3080 = -t413*t1440-t825*t510-t3064-t3065+t413*t1450+t413*t653-t810*t2717-t413*t486-t3070-t433*t1694+t1562*t2295+t433*t13-t3074-t3075-t3078-t1562*t937;
+              const double t3083 = t366*t1645;
+              const double t3084 = t393*t497;
+              const double t3085 = t393*t576;
+              const double t3088 = t341*t16;
+              const double t3089 = t341*t96;
+              const double t3090 = t824*t465;
+              const double t3091 = t341*t371;
+              const double t3092 = t341*t2480;
+              const double t3093 = t824*t467;
+              const double t3094 = t290*t2304;
+              const double t3095 = t290*t937;
+              const double t3096 = t1772*eta;
+              const double t3097 = t18*t3096;
+              const double t3098 = -t433*t110+t433*t506+t3083-t3084+t3085-t1035*t106+t810*t467-t3088+t3089+t3090+t3091-t3092-t3093-t3094-t3095-t3097;
+              const double t3100 = t290*vertices[6](1);
+              const double t3102 = t393*t396;
+              const double t3106 = t18*t1937;
+              const double t3113 = t290*t1645;
+              const double t3114 = t733*eta;
+              const double t3116 = 2.0*t3114*t345;
+              const double t3118 = t393*t398;
+              const double t3119 = t3100*t2620-t3102+t1035*t11+t721*t1694-t721*t13+t3106-t1171*t96+t950*t106+t1171*t16+t837*t96-t1171*t371+t1171*t2480+t3113-t3116+t828*t2304+t3118;
+              const double t3123 = t559*t103;
+              const double t3125 = t290*t1390;
+              const double t3126 = t341*t1393;
+              const double t3128 = 2.0*t828*t16;
+              const double t3130 = 2.0*t828*t11;
+              const double t3131 = t290*vertices[4](1);
+              const double t3133 = 2.0*t3131*t747;
+              const double t3135 = 2.0*t2240*t531;
+              const double t3137 = 2.0*t3131*t669;
+              const double t3139 = 2.0*t2240*t747;
+              const double t3141 = 2.0*t2240*t669;
+              const double t3142 = t860*t485;
+              const double t3143 = t341*t31;
+              const double t3144 = t447*t1180;
+              const double t3145 = -t828*t2295-t828*t2018-t560*t937-t3123+t828*t937+t3125+t3126-t3128-t3130-t3133-t3135+t3137+t3139-t3141-t3142+t3143-t3144;
+              const double t3150 = t337*vertices[3](2);
+              const double t3151 = t341*t36;
+              const double t3152 = t341*t1645;
+              const double t3155 = 2.0*t828*t110;
+              const double t3157 = 2.0*t2527*t1273;
+              const double t3160 = 2.0*t828*t120;
+              const double t3164 = t447*t1167;
+              const double t3165 = t290*t1486;
+              const double t3166 = t290*t1492;
+              const double t3168 = t720*t1645;
+              const double t3169 = -t3150+t3151-t3152+t378*t445-t3155+t3157-t1171*t1064+t3160+t1171*t421-t1035*t343+t1171*t115+t3164+t3165-t3166-t787*t467+t3168;
+              const double t3170 = t720*t500;
+              const double t3171 = t720*t67;
+              const double t3172 = t720*t1380;
+              const double t3173 = t51*xi;
+              const double t3175 = 2.0*t358*t3173;
+              const double t3176 = t720*t1393;
+              const double t3177 = t559*t1390;
+              const double t3182 = t140*t850;
+              const double t3184 = 2.0*t334*t297;
+              const double t3185 = t1193*t2453;
+              const double t3186 = t559*t1492;
+              const double t3187 = t720*t31;
+              const double t3188 = t720*t36;
+              const double t3189 = -t3170+t3171+t3172-t3175-t3176-t3177+t1035*t42-t1035*t38+t1035*t1293-t1035*t1922+t3182-t3184+t3185+t3186-t3187-t3188;
+              const double t3200 = t679*t543;
+              const double t3202 = 2.0*t413*t11;
+              const double t3203 = t334*t976;
+              const double t3206 = 2.0*t413*t16;
+              const double t3209 = -t560*t1609+t560*t1509-t560*t1450+t560*t1440-t810*t510-t560*t653+t560*t486+t721*t1064-t721*t115+t3200+t3202+t3203-t950*t42+t3206+t950*t38-t950*t1293;
+              const double t3210 = t679*t2978;
+              const double t3213 = t679*t445;
+              const double t3221 = 2.0*t413*t38;
+              const double t3223 = t1202*xi;
+              const double t3228 = -t3210-t825*t465+t825*t467-t3213+t950*t1922-t950*t459+t950*t343-t810*t2874-t837*t421+t837*t120-t3221+t787*t2874-t787*t3223+t1159*t702-t1159*t725-t1159*t623;
+              const double t3232 = 2.0*t1562*t57;
+              const double t3233 = t1820*t531;
+              const double t3235 = 2.0*t1562*t65;
+              const double t3236 = t824*t509;
+              const double t3238 = 2.0*t1562*t13;
+              const double t3240 = 2.0*t309*t168;
+              const double t3242 = t1562*t110;
+              const double t3245 = 2.0*t1562*t115;
+              const double t3248 = t290*t38;
+              const double t3249 = t290*t42;
+              const double t3250 = t290*t67;
+              const double t3253 = t3232-t3233-t3235-t3236-t3238-t3240+t1159*t517+4.0*t3242-t3245-t2240*t2620+t2240*t2251-t3248+t3249-t3250-t3100*t2251+t3100*t493;
+              const double t3254 = t290*t16;
+              const double t3255 = t1820*t1255;
+              const double t3258 = t437*t2450;
+              const double t3259 = t559*t1486;
+              const double t3261 = 2.0*t1635*t531;
+              const double t3262 = t437*vertices[3](1);
+              const double t3263 = t679*t788;
+              const double t3265 = 2.0*t290*t31;
+              const double t3266 = vertices[5](0)*vertices[2](1);
+              const double t3267 = t3266*zeta;
+              const double t3269 = 2.0*t3267*t1273;
+              const double t3271 = 2.0*t290*t103;
+              const double t3272 = t290*t106;
+              const double t3273 = t290*t120;
+              const double t3274 = t290*t110;
+              const double t3275 = t341*t1064;
+              const double t3276 = t3254+t3255-t3100*t490+t378*t462-t3258-t3259+t3261-t3262+t3263-t3265+t3269+t3271-t3272-t3273+t3274+t3275;
+              const double t3278 = t341*t115;
+              const double t3279 = t341*t421;
+              const double t3280 = t341*t120;
+              const double t3281 = t341*t1380;
+              const double t3283 = t341*t67;
+              const double t3284 = t349*t3006;
+              const double t3289 = t650*vertices[4](2);
+              const double t3290 = t156*t3289;
+              const double t3291 = t156*t3006;
+              const double t3292 = t349*t3289;
+              const double t3293 = t711*vertices[0](2);
+              const double t3294 = t156*t3293;
+              const double t3295 = t711*vertices[3](2);
+              const double t3296 = t156*t3295;
+              const double t3297 = -t3278-t3279+t3280-t3281+t2240*t490-t3283-t3284-t787*t1176+t787*t947-t825*t610+t825*t2854-t3290+t3291+t3292+t3294-t3296;
+              const double t3298 = t603*vertices[0](2);
+              const double t3299 = t156*t3298;
+              const double t3302 = t824*t1182;
+              const double t3303 = t523*vertices[7](2);
+              const double t3304 = t824*t3303;
+              const double t3306 = t824*t2854;
+              const double t3307 = t156*t888;
+              const double t3308 = t824*t610;
+              const double t3309 = t156*t3223;
+              const double t3310 = t156*t3034;
+              const double t3311 = t156*t3032;
+              const double t3312 = t437*t51;
+              const double t3314 = t156*t848;
+              const double t3315 = t156*t2856;
+              const double t3317 = 2.0*t349*t1203;
+              const double t3318 = -t3299+t810*t1176-t810*t947-t3302+t3304+t810*t789-t3306-t3307+t3308+t3309-t3310+t3311-t3312-t2970*t1301+t3314-t3315-t3317;
+              const double t3322 = t51*t350;
+              const double t3325 = t739*t1847;
+              const double t3329 = 2.0*t349*t1191;
+              const double t3331 = t836*vertices[0](1);
+              const double t3332 = t252*t3331;
+              const double t3333 = t479*t1444;
+              const double t3334 = t831*t1194;
+              const double t3337 = 2.0*t349*t857;
+              const double t3342 = -t3322*t462-t3322*t623-t3325+t3322*t353+t787*t510+t3329-t378*t2854-t3332-t3333-t3334-t1214*t2854-t3337+t1214*t610-t1159*t2874+t3322*t1301+t1159*t2907;
+              const double t3345 = t140*t3289;
+              const double t3346 = t140*t3298;
+              const double t3347 = t140*t3293;
+              const double t3348 = t140*t3295;
+              const double t3349 = t778*t3303;
+              const double t3350 = t792*t120;
+              const double t3351 = t778*t1182;
+              const double t3352 = t349*t1182;
+              const double t3355 = t606*t2450;
+              const double t3359 = t1709*vertices[4](1);
+              const double t3360 = t252*t3359;
+              const double t3361 = t378*t610-t1159*t1937+t3345+t3346-t3347+t3348-t3349+t3350+t3351-3.0*t3352+t351*t1098+t3355+t810*t3223+t351*t1160-t351*t647-t3360;
+              const double t3363 = t606*t2453;
+              const double t3364 = t443*t647;
+              const double t3365 = t377*t2854;
+              const double t3366 = t377*t610;
+              const double t3367 = t606*t3173;
+              const double t3368 = t679*t1301;
+              const double t3371 = t18*t353;
+              const double t3372 = t443*t1098;
+              const double t3374 = 2.0*t437*t3173;
+              const double t3375 = t443*t1160;
+              const double t3376 = t18*t647;
+              const double t3377 = t349*t3295;
+              const double t3378 = t349*t3293;
+              const double t3379 = t230*t868;
+              const double t3380 = -t3363+t3364+t3365-t3366-t3367+t3368-t351*t2978+t351*t2145-t3371-t3372+t3374-t3375+t3376+t3377-t3378+t3379;
+              const double t3381 = t377*t3303;
+              const double t3382 = t824*t300;
+              const double t3384 = 2.0*t2011*t353;
+              const double t3386 = 2.0*t1815*t1255;
+              const double t3387 = t437*t321;
+              const double t3388 = t479*t489;
+              const double t3390 = t377*t1182;
+              const double t3391 = t443*t2978;
+              const double t3393 = 2.0*t18*t455;
+              const double t3394 = t18*t1178;
+              const double t3395 = t334*t304;
+              const double t3396 = t334*t307;
+              const double t3398 = 2.0*t2011*t647;
+              const double t3399 = t453*t3096;
+              const double t3400 = t1379*t961;
+              const double t3401 = t230*t643;
+              const double t3402 = -t3381+t3382-t3384-t3386-t3387-t3388+t351*t1301+t3390+t3391-t3393+t3394+t3395-t3396+t3398+t3399+t3400-t3401;
+              const double t3405 = t233*t489;
+              const double t3406 = t349*t717;
+              const double t3407 = t349*t3298;
+              const double t3408 = t323*t409;
+              const double t3410 = t255*t328;
+              const double t3411 = t1820*t1146;
+              const double t3412 = t156*t454;
+              const double t3413 = t727*t343;
+              const double t3414 = t447*vertices[0](2);
+              const double t3416 = t334*t1564;
+              const double t3417 = t444*t474;
+              const double t3418 = t377*t780;
+              const double t3419 = t444*t356;
+              const double t3420 = t334*t1146;
+              const double t3421 = t3405-t3406+t3407-t3408+t351*t543-t3410-t3411+t3412+t3413+t3414-t351*t445+t3416+t3417-t3418-t3419-t3420;
+              const double t3423 = 2.0*t923*t477;
+              const double t3424 = t443*t437;
+              const double t3425 = t923*t1945;
+              const double t3426 = t444*t2564;
+              const double t3427 = t1820*t1564;
+              const double t3428 = t156*t1027;
+              const double t3430 = 2.0*t444*t1194;
+              const double t3431 = t831*t356;
+              const double t3432 = t923*t1146;
+              const double t3433 = t923*t661;
+              const double t3434 = t309*t976;
+              const double t3435 = t831*t474;
+              const double t3436 = t595*t661;
+              const double t3437 = t923*t1564;
+              const double t3438 = t334*vertices[4](2);
+              const double t3439 = t443*t2145;
+              const double t3440 = -t3423+t3424+t3425-t3426+t3427-t3428+t3430+t3431+t3432+t3433-t3434-t3435+t3436-t3437+t3438-t3439;
+              const double t3442 = t230*t1318;
+              const double t3443 = t429*vertices[2](1);
+              const double t3445 = 2.0*t3443*t591;
+              const double t3446 = t393*t513;
+              const double t3447 = t349*t353;
+              const double t3448 = t425*t112;
+              const double t3449 = t393*t638;
+              const double t3450 = t679*t353;
+              const double t3452 = 2.0*t255*t1004;
+              const double t3453 = t679*t623;
+              const double t3454 = t230*t706;
+              const double t3456 = 2.0*t3443*t661;
+              const double t3457 = t255*t1019;
+              const double t3458 = t679*t462;
+              const double t3459 = t958*t1146;
+              const double t3461 = 2.0*t255*t384;
+              const double t3462 = t958*t304;
+              const double t3463 = t3442-t3445-t3446+t3447+t3448-t3449+t3450+t3452-t3453+t3454+t3456+t3457-t3458+t3459+t3461-t3462;
+              const double t3464 = t349*t1668;
+              const double t3465 = t958*t297;
+              const double t3466 = t230*t569;
+              const double t3468 = t958*t1564;
+              const double t3469 = t255*t980;
+              const double t3472 = 2.0*t255*t734;
+              const double t3473 = t255*t576;
+              const double t3474 = t958*t307;
+              const double t3475 = t824*t887;
+              const double t3476 = t860*t598;
+              const double t3477 = t479*t1055;
+              const double t3478 = t349*t647;
+              const double t3479 = t479*t396;
+              const double t3480 = t1193*t3173;
+              const double t3481 = t412*vertices[1](1);
+              const double t3483 = 2.0*t3481*t747;
+              const double t3484 = t479*t970;
+              const double t3485 = t3464+t3465+t3466+t378*t510-t3468-3.0*t3469-t3472-t3473+t3474+t3475-t3476-t3477-t3478+t3479+t3480+t3483+t3484;
+      double s1 = t761+t664+t625+t2021+t2839+t1184+t1371+t2312+t471+t2926+t1212+t516+t1107+t1039+t1236+t1576+t1827+t2861+t2047+t1396+t2402+t879+t3253+t3209+t553+t1422+t585+t2380+t2332+t906+t1262+t1086+t1063+t1130+t987+t1852+t2073+t819+t2882+t1285+t732+t1446+t2355+t956+t1697+t2988+t694+t1472+t3228+t2559+t2092+t3361+t1949+t1626+t2904+t3012+t794+t3030+t1498+t3059+t3080+t1648+t2117+t855;
+              const double t3492 = s1+t3421+t1521+t2423+t2140+t2630+t2161+t3276+t1548+t3098+t2945+t1672+t928+t1316+t333+t374+t1334+t2184+t2965+t2235+t2449+t1156+t3297+t1875+t2539+t2206+t1926+t1717+t3440+t3318+t1740+t3145+t1759+t2606+t2469+t2583+t1782+t1804+t2263+t1999+t1971+t2492+t423+t3463+t1014+t3342+t3485+t2288+t2516+t1603+t2671+t2721+t2652+t3119+t2696+t1900+t1353+t3402+t3380+t2744+t2772+t2795+t3189+t3169+t2819;
+              const double t3493 = 1/t3492;
+              const double t3495 = -t12-t13-t16+t26+t31-t36+t415-t942+t578+t521-t526;
+              const double t3496 = t529-t540-t545+t547-t551+t557+t38-t42-t45-t52+t57;
+              const double t3498 = t60-t65+t67+t69-t72+t75-t76+t79+t81-t85-t86;
+              const double t3499 = -t89+t93+t96-t419-t103+t107+t108+t110+t112-t116-t117;
+              const double t3502 = 2.0*t175;
+              const double t3503 = t120+t125-t126-t128-t133+t134+t164-t166+t169-t3502-t177;
+              const double t3504 = 2.0*t178;
+              const double t3505 = 2.0*t182;
+              const double t3507 = t3504-t180+t181-t3505+t184-t185+2.0*t186-t188+t190+t192+t193;
+              const double t3510 = 2.0*t201;
+              const double t3511 = -t194-t195-t197+2.0*t199+t200-t3510+t203+t205-t207-t208+t209;
+              const double t3514 = 2.0*t219;
+              const double t3516 = -t211+t213-t214+2.0*t215+2.0*t216-t217+t218-t3514+t220-2.0*t221+t237;
+              const double t3520 = t302*vertices[1](2);
+              const double t3522 = t302*vertices[0](2);
+              const double t3525 = -t238-t241-t2304+t2295+t2018-t2127-t937+t2507-t8*t3520+t8*t3522+t616*t255;
+              const double t3531 = vertices[2](2)*eta;
+              const double t3538 = -t8*t1150+t8*t1167+t414*t165-t414*t222-t414*t168+t414*t3531-t550*t165+t550*t222+t550*t168-t550*t3531-t616*t212;
+              const double t3551 = -t1162*t210+t1162*t252-t1162*t255+t1162*t212+t1162*t165-t1162*t222-t1162*t168+t1162*t3531+t485*t210-t485*t252+t485*t255;
+              const double t3562 = -t485*t212-t485*t165+t485*t222+t485*t168-t485*t3531+t616*t210-t616*t252-t528*t189-t105+t520*t204-t520*t279;
+              const double t3565 = vertices[5](2)*zeta;
+              const double t3574 = t520*t3565-t520*t206-t528*t230+t528*t233-t261+t114+t1509+t616*t230-t616*t187-t616*t233+t616*t189;
+              const double t3581 = t520*t230-t520*t187-t520*t233+t10+t520*t189+t265-t25-t91-t1609-t51*t917+t51*t1523;
+              const double t3592 = t51*t3520-t51*t3522-t271-t1450-t528*t204+t528*t279-t528*t3565+t528*t206+t550*t204-t550*t279+t550*t3565;
+              const double t3599 = -t550*t206-t414*t204+t83+t414*t279-t414*t3565+t414*t206+t1440+t486-t653+t276+t528*t187;
+              const double t3604 = t3492*t3492;
+              const double t3605 = 1/t3604;
+              const double t3606 = (t3495+t3496+t3498+t3499+t3503+t3507+t3511+t3516+t3525+t3538+t3551+t3562+t3574+t3581+t3592+t3599)*t3605;
+              const double t3607 = 2.0*t291;
+              const double t3611 = 2.0*t606*t321;
+              const double t3612 = vertices[5](0)*vertices[3](1);
+              const double t3615 = 2.0*t831*t2564;
+              const double t3617 = -t3607+t293+t299-2.0*t301-t320+t424*t768-t3611+t479*t3612-t327-t3615+2.0*t329;
+              const double t3618 = 2.0*t331;
+              const double t3621 = t40*zeta;
+              const double t3623 = t1379*vertices[7](1);
+              const double t3625 = t674*vertices[7](1);
+              const double t3627 = t674*vertices[4](1);
+              const double t3629 = t447*zeta;
+              const double t3632 = t3618-t332+t309*vertices[2](2)+t335-t338-t330*vertices[5](1)-t339+t720*t3621+t252*t3623-t230*t3625-t222*t3627+2.0*t230*t3629;
+              const double t3643 = t469*vertices[2](2);
+              const double t3647 = t358*vertices[2](1)+t292*vertices[5](1)-2.0*t230*t3076-2.0*t348-t447*vertices[2](2)+t495*vertices[0](1)-t1193*vertices[0](1)-t495*vertices[4](1)-t3643-t292*vertices[2](1)+t441*vertices[2](2)-t908*vertices[0](2);
+              const double t3650 = t733*vertices[3](2);
+              const double t3651 = 2.0*t361;
+              const double t3656 = vertices[6](1)*t350;
+              const double t3657 = t3656*vertices[0](2);
+              const double t3659 = t337*vertices[5](2)+t1774*vertices[0](2)-t3650+t359+t3651+t908*vertices[3](2)-t337*vertices[2](2)-t252*t383-2.0*t370+t403-t418-t620*t3657;
+              const double t3665 = t3656*vertices[3](2);
+              const double t3671 = 2.0*t442;
+              const double t3672 = 2.0*t448;
+              const double t3673 = t230*t568-2.0*t255*t733-t427+t620*t3665-t431-t341*t19-2.0*t1635*t179-t255*t1365-t440-t3671+t3672;
+              const double t3681 = t18*vertices[0](2);
+              const double t3683 = t147*vertices[4](2);
+              const double t3687 = -t451-2.0*t452-t457+2.0*t2990*t976+2.0*t620*t152+2.0*t470+2.0*t478+t341*t3681+t341*t3683-t341*t149+t492+t252*t733;
+              const double t3691 = t635*vertices[3](2);
+              const double t3693 = t768*vertices[4](2);
+              const double t3697 = vertices[6](1)*vertices[3](2);
+              const double t3699 = 2.0*t501+t252*t334+t3691+t1193*vertices[3](1)+t3693-t360*vertices[5](2)-t1774*vertices[4](2)-t504+t958*vertices[4](2)-t674*t3697+t512+t515;
+              const double t3702 = t893*vertices[5](2);
+              const double t3707 = t444*t18;
+              const double t3711 = vertices[5](1)*t350;
+              const double t3712 = t3711*vertices[3](2);
+              const double t3714 = 2.0*t560*t49-t620*t3702+t525-t533-t720*t29+t230*t441-t1379*t4-t3707+t556-2.0*t828*t49-t230*t447-t620*t3712;
+              const double t3718 = t437*t140;
+              const double t3719 = t3711*vertices[0](2);
+              const double t3721 = t893*vertices[6](2);
+              const double t3723 = t443*vertices[7](2);
+              const double t3725 = t443*vertices[4](2);
+              const double t3732 = vertices[6](0)*vertices[3](1);
+              const double t3734 = -t3718+t620*t3719+t620*t3721+t559*t3723-t559*t3725-2.0*t736*t285-2.0*t587-2.0*t588+t594-2.0*t596-t479*t3732;
+              const double t3735 = 2.0*t602;
+              const double t3738 = t453*vertices[3](2);
+              const double t3740 = vertices[6](0)*t350;
+              const double t3741 = t3740*vertices[0](1);
+              const double t3745 = vertices[5](0)*t350;
+              const double t3746 = t3745*vertices[0](1);
+              const double t3748 = t3745*vertices[3](1);
+              const double t3750 = 2.0*t621;
+              const double t3753 = t3735+t720*t9+t605+2.0*t607+t720*t3738-t233*t3741+2.0*t792*t285+t233*t3746-t233*t3748-t3750+t631+2.0*t736*t54;
+              const double t3759 = t679*vertices[4](2);
+              const double t3762 = t1709*vertices[1](1);
+              const double t3764 = t1709*vertices[5](1);
+              const double t3766 = 2.0*t255*t383-2.0*t1774*t976-t634+t559*t3759+t479*t476-t642+t252*t3762-t252*t3764+t646+t652+t656+t658;
+              const double t3768 = 2.0*t635*t1180;
+              const double t3769 = 2.0*t677;
+              const double t3770 = t860*t5;
+              const double t3772 = t3740*vertices[3](1);
+              const double t3775 = 2.0*t476*t747;
+              const double t3776 = 2.0*t693;
+              const double t3777 = vertices[5](0)*zeta;
+              const double t3778 = t3777*vertices[0](2);
+              const double t3781 = t660-t673+t3768-t675+t3769+2.0*t3770+t680+t233*t3772-t685+t3775-t3776+2.0*t349*t3778;
+              const double t3784 = t64*eta;
+              const double t3787 = t352*zeta;
+              const double t3793 = t1029*eta;
+              const double t3796 = -2.0*t736*t3784-2.0*t349*t3787+t698-t674*t98+t713-t715-t716-2.0*t362*t409+t718+t724+2.0*t453*t3793;
+              const double t3798 = t429*vertices[2](2);
+              const double t3801 = 2.0*t748;
+              const double t3803 = t324*vertices[1](2);
+              const double t3806 = -t729+t737-t738+t741+t674*t64+2.0*t349*t3798-t3801-t750-t720*t278+t753-t754-2.0*t736*t3803;
+              const double t3808 = 2.0*t757;
+              const double t3810 = -t3808+t759-t760+t764-4.0*t771-t773-t774-t775-t776-t777+t781+t784;
+              const double t3815 = t476*t187;
+              const double t3816 = t679*vertices[7](2);
+              const double t3818 = t156*vertices[0](2);
+              const double t3821 = 2.0*t803;
+              const double t3822 = 2.0*t804;
+              const double t3823 = -2.0*t495*t817-2.0*t255*t1701+t791-t3815+t793-t559*t3816+2.0*t736*t3818+t795-t799+t801+t3821-t3822;
+              const double t3829 = t377*vertices[7](2);
+              const double t3832 = t1213*vertices[1](2);
+              const double t3837 = t383*eta;
+              const double t3839 = t20*eta;
+              const double t3842 = -2.0*t805+t809+t736*t3829+t816-2.0*t818-t736*t3832-2.0*t495*t5-2.0*t832-t835-t739*t3837+2.0*t736*t3839;
+              const double t3843 = t377*vertices[3](2);
+              const double t3846 = 2.0*t854;
+              const double t3847 = t824*vertices[3](2);
+              const double t3849 = t1213*vertices[5](2);
+              const double t3851 = 2.0*t861;
+              const double t3854 = -t736*t3843-t841-t844+t727*t3784+t849+t851+t3846+t736*t3847-t858+t736*t3849-t3851+2.0*t362*t2564;
+              const double t3856 = 2.0*t865;
+              const double t3857 = 2.0*t869;
+              const double t3861 = t390*eta;
+              const double t3863 = -t3856+t3857-t871-t872+2.0*t2187*t23-t674*t273-t874+t876+t877+t739*t3861-t889-t891;
+              const double t3864 = t290*vertices[3](2);
+              const double t3867 = t461*zeta;
+              const double t3871 = 2.0*t920;
+              const double t3872 = -t898-t900-t901-t903+2.0*t18*t3864+t377*t3867+t907-2.0*t2187*t6+t914-t915-t919-t3871;
+              const double t3876 = 2.0*t924;
+              const double t3878 = 2.0*t921-t3876-t925+t927-t932-2.0*t933-t935-t936+t940+t941+t944;
+              const double t3882 = 2.0*t960;
+              const double t3883 = vertices[6](1)*vertices[0](2);
+              const double t3885 = 2.0*t966;
+              const double t3888 = t952+t953+2.0*t290*t49+2.0*t955-t957-t3882+t674*t3883-t3885-2.0*t977-t978-t982+t1193*t51;
+              const double t3890 = 2.0*t991;
+              const double t3891 = t140*vertices[3](2);
+              const double t3895 = -t985-t986+t3890+t993-t727*t3891+t994+t1006-t1008-t1009+t727*t142+t727*t157+t1011;
+              const double t3896 = 2.0*t1020;
+              const double t3899 = t3777*vertices[3](2);
+              const double t3903 = t341*vertices[7](1);
+              const double t3906 = -t1013+t1016+t3896+t674*t284-t727*t3818+t1021+t778*t3899-2.0*t1026+2.0*t1028-t1032-t252*t3903-t727*t284;
+              const double t3911 = 3.0*t1043;
+              const double t3912 = 2.0*t1057;
+              const double t3913 = 2.0*t1060;
+              const double t3914 = t609*zeta;
+              const double t3917 = t1029*zeta;
+              const double t3920 = -t479*t765+t1034-t1041+t3911-t1054-t3912-t3913+2.0*t156*t3914-2.0*t156*t3917+t1074+t1078;
+              const double t3922 = t711*vertices[2](2);
+              const double t3924 = 2.0*t1083;
+              const double t3926 = 2.0*t1092;
+              const double t3928 = t824*vertices[7](2);
+              const double t3930 = -t156*t609-t156*t3922-t1080-t3924+t1085-t824*t831+t1090-t3926-t1094+t479*t733+t1096-t736*t3928;
+              const double t3932 = 2.0*t1114;
+              const double t3933 = 2.0*t1115;
+              const double t3935 = t736*vertices[0](2);
+              const double t3937 = t836*vertices[5](2);
+              const double t3939 = -t1109+t3932-t3933-t1117+t1120+t1123+t1124+t1379*t3+t1126+t1128+t377*t3935-t18*t3937;
+              const double t3940 = t836*vertices[1](2);
+              const double t3942 = t1709*vertices[5](2);
+              const double t3945 = t711*vertices[1](2);
+              const double t3947 = t622*eta;
+              const double t3952 = vertices[1](0)*vertices[4](2);
+              const double t3953 = t3952*zeta;
+              const double t3957 = -t1137+t18*t3940+t1139-t1143+t18*t3942-t393*t768+t156*t3945-2.0*t18*t3947-t1379*t100+t140*t3922+2.0*t156*t3953+t727*t3697;
+              const double t3960 = 2.0*t1181;
+              const double t3961 = t330*zeta;
+              const double t3964 = t461*eta;
+              const double t3966 = t736*vertices[4](2);
+              const double t3969 = t352*eta;
+              const double t3971 = 2.0*t1211;
+              const double t3972 = vertices[6](0)*zeta;
+              const double t3973 = t3972*vertices[4](2);
+              const double t3975 = -t3960-2.0*t156*t3961+t1188+t1189+t1196+t679*t3964+t1205-2.0*t156*t3966-t679*t3969-t3971-t824*t3973;
+              const double t3977 = 2.0*t1222;
+              const double t3979 = 2.0*t1225;
+              const double t3982 = 2.0*t1241;
+              const double t3983 = t603*vertices[2](2);
+              const double t3985 = t1219+t679*t3947+t1220-t3977+t727*t273-t3979+t156*t1029-t1230-t727*t3883-t1240-t3982+t156*t3983;
+              const double t3987 = t603*vertices[1](2);
+              const double t3989 = t358*zeta;
+              const double t3992 = t3745*vertices[0](2);
+              const double t3994 = 2.0*t1251;
+              const double t3995 = t2853*zeta;
+              const double t3999 = -t156*t3987+t1246-2.0*t156*t3989-t349*t3992+t1250-t3994-t1257-t1260-t377*t3995-2.0*t1264-t1268-2.0*t1269;
+              const double t4006 = 2.0*t1303;
+              const double t4007 = -t1272+2.0*t958*t976-t1280+t958*t204-t679*t461-2.0*t792*t146-t1291-t1292-t1296+t1298+t1299+t4006;
+              const double t4015 = t3777*vertices[0](1);
+              const double t4018 = t412*vertices[5](2);
+              const double t4021 = t412*vertices[1](2);
+              const double t4024 = 2.0*t1820*t661+t1305-2.0*t233*t4015-t1306+2.0*t18*t4018+t1309+t1311-t1313+t1315-2.0*t18*t4021-t1317;
+              const double t4027 = t1709*vertices[1](2);
+              const double t4032 = t650*vertices[6](2);
+              const double t4035 = -t1319+2.0*t1320-2.0*t1322+t1325-t1326+t1328-t18*t4027+t1330+t727*t98-2.0*t792*t41-t349*t4032-t377*t860;
+              const double t4039 = t650*vertices[5](2);
+              const double t4043 = t330*eta;
+              const double t4046 = 2.0*t1338+2.0*t1343-t1346+t1347+t349*t4039-2.0*t958*t661-t1351-t1352+t1355+t1356-t1357+2.0*t18*t4043;
+              const double t4047 = t449*vertices[5](2);
+              const double t4050 = vertices[2](0)*vertices[4](2);
+              const double t4053 = 2.0*t1369;
+              const double t4055 = t1363-t349*t4047+t1364+2.0*t1366+t377*t4050-t1368-t377*t3966-t4053-2.0*t1370+t1374-t1375-t1376;
+              const double t4059 = t425*t64;
+              const double t4060 = vertices[5](0)*vertices[3](2);
+              const double t4062 = vertices[6](0)*vertices[3](2);
+              const double t4066 = -2.0*t1378+t4059-t1381-t1382-t443*t4060+t443*t4062-t443*t831-t1384+t1389+t1391+t377*t2853;
+              const double t4075 = t443*t606+t1394+t1252*t210-t1252*t212-t1379*t3681+t377*t3914-t679*t4062-t447*t222-t377*t609+t1401-t1405-t1409;
+              const double t4077 = 3.0*t1414;
+              const double t4078 = 2.0*t1416;
+              const double t4079 = 2.0*t1417;
+              const double t4081 = 2.0*t1436;
+              const double t4082 = t1410+t1412-t4077-t4078+t4079-t1424-t1379*t3683+t1427-t1428+t1429+t1433+t4081;
+              const double t4087 = 2.0*t1460;
+              const double t4088 = t1438+t1439+t441*t222-t1443-t1445-t1449-t1453-t1456+t1379*t149-2.0*t909*t1180-t4087-t1461;
+              const double t4093 = vertices[2](0)*vertices[4](1);
+              const double t4095 = 2.0*t1462;
+              const double t4097 = 2.0*t1465;
+              const double t4098 = 2.0*t1466;
+              const double t4099 = -t1820*t210-t393*t4093-t4095-t479*t383-t1464-t4097-t4098+t1467-t1469+t1471-t1476;
+              const double t4104 = 2.0*t1480;
+              const double t4105 = 2.0*t1481;
+              const double t4107 = t449*vertices[6](2);
+              const double t4109 = 2.0*t1490;
+              const double t4110 = t1477+t337*t279+2.0*t1635*t210+t1820*t212+t4104+t4105+2.0*t1482-t1483+t1487-t1489+t349*t4107+t4109;
+              const double t4112 = 2.0*t1494;
+              const double t4113 = t3740*vertices[0](2);
+              const double t4116 = t3740*vertices[3](2);
+              const double t4120 = t1491-t1493+t4112+t349*t4113-2.0*t1496+t1497-t349*t4116+t679*t1300-t1500-t864*t230+t1501-t1502;
+              const double t4122 = 3.0*t1506;
+              const double t4124 = t3745*vertices[3](2);
+              const double t4127 = 2.0*t1518;
+              const double t4130 = 2.0*t1533;
+              const double t4131 = 2.0*t1503+t1505-t4122+t1513+t1515+t1379*t19+t349*t4124-t736*t20+t4127-t1526-2.0*t1820*t747-t4130;
+              const double t4134 = vertices[1](0)*vertices[3](2);
+              const double t4135 = t4134*eta;
+              const double t4142 = t437*vertices[2](1);
+              const double t4143 = 2.0*t1556;
+              const double t4149 = -2.0*t18*t4135+2.0*t1639*t1180+t1545+2.0*t1635*t747-t4142+t4143-2.0*t309*t3531+t1561-t923*t252+t453*t860+t377*t831;
+              const double t4152 = 3.0*t1567;
+              const double t4153 = 2.0*t1580;
+              const double t4155 = t366*vertices[1](2);
+              const double t4158 = 2.0*t1581;
+              const double t4159 = 2.0*t1586;
+              const double t4160 = 2.0*t1588;
+              const double t4163 = -2.0*t736*t157-t4152-t1570+t4153+t309*t222+2.0*t18*t4155+t4158+t1584+t4159+t4160+t1590+2.0*t908*t1180;
+              const double t4165 = 2.0*t1591;
+              const double t4166 = 2.0*t1594;
+              const double t4167 = t499*t606;
+              const double t4168 = t508*t4050;
+              const double t4169 = t341*vertices[3](2);
+              const double t4172 = t341*vertices[7](2);
+              const double t4174 = t425*t273;
+              const double t4175 = 2.0*t1604;
+              const double t4176 = t4165-t1593-t4166+t4167+t4168-t18*t4169-4.0*t1596+t1600+t18*t4172-t4174-t1602-t4175;
+              const double t4179 = 2.0*t1612;
+              const double t4180 = 2.0*t1614;
+              const double t4181 = 2.0*t1616;
+              const double t4187 = 3.0*t1628;
+              const double t4188 = t1607-2.0*t736*t153+t4179-t4180-t4181+t1619+t679*t4060+t679*t831-2.0*t2494*t1180-t1622+2.0*t1625+t4187;
+              const double t4196 = t1379*vertices[3](2);
+              const double t4198 = t1379*vertices[7](2);
+              const double t4200 = 3.0*t1651;
+              const double t4201 = 2.0*t1661;
+              const double t4202 = -t679*t606-t18*t4060-t1643+t479*t390+t18*t4196-t1646-t18*t4198+t1647+t4200+t1655+t4201;
+              const double t4205 = 2.0*t1669;
+              const double t4206 = 2.0*t1670;
+              const double t4207 = vertices[6](1)*vertices[4](2);
+              const double t4212 = 2.0*t765*t661;
+              const double t4215 = 2.0*t736*t155-t1665+t4205-t4206+t1379*t4207-t18*t358-t18*t330-t1688+t4212+2.0*t1692+2.0*t1704-t1705;
+              const double t4223 = 2.0*t1728;
+              const double t4224 = 2.0*t1730;
+              const double t4225 = t1707-t393*t3076-t1711-t1379*t3883+t393*t568-t1722+t362*t508-t362*t324+2.0*t1725-t1727+t4223+t4224;
+              const double t4229 = vertices[6](0)*vertices[4](2);
+              const double t4234 = 2.0*t1745;
+              const double t4236 = t366*t119;
+              const double t4238 = -2.0*t1731-2.0*t349*t3914-t1733-t377*t4229-2.0*t349*t4050-t349*t622-t1735-t1743+t4234+t393*t765-t4236-t330*t147;
+              const double t4241 = 2.0*t1755;
+              const double t4242 = 2.0*t1763;
+              const double t4243 = t366*t274;
+              const double t4248 = t4241+t4242+t1768+t4243+2.0*t736*t41+t1771-t1773+t447*t252+t334*vertices[5](2)+t1776-t1777;
+              const double t4252 = 2.0*t768*t976;
+              const double t4258 = t1252*t189+t1778+2.0*t1779-t1780+t4252-t1635*t165+t1820*t187-t1781-t958*vertices[0](2)+t1788+t1789-2.0*t1635*t1180;
+              const double t4270 = t908*t165-t393*t1075+t1790-t1379*t275+t1791-t1792+t292*t147-t1793-2.0*t453*t622-t453*t1029+2.0*t233*t1683+t393*t2527;
+              const double t4278 = 2.0*t1808;
+              const double t4280 = -t393*t2536+t1796+t1797-t1799+t18*t622+2.0*t349*t860-t1820*t189+2.0*t349*t609+t4278-t1810-t1811+t1379*t274;
+              const double t4286 = 2.0*t1814;
+              const double t4287 = t622*zeta;
+              const double t4291 = 2.0*t1821;
+              const double t4293 = t1075*zeta;
+              const double t4295 = -t1813-2.0*t349*t3935-t4286+2.0*t349*t4287+2.0*t1817+t1819-t4291-2.0*t1824+t393*t4293-t1826-t1830;
+              const double t4298 = t3972*vertices[0](2);
+              const double t4300 = 2.0*t1836;
+              const double t4301 = t489*t222;
+              const double t4302 = t635*t210;
+              const double t4303 = -2.0*t1831+t377*t3973-t1833-t377*t4298+t4300+t1837-t1839-t1849-t1851+t4301-t4302+t1863;
+              const double t4306 = t559*vertices[0](1);
+              const double t4308 = t768*t204;
+              const double t4309 = 2.0*t1877;
+              const double t4310 = t476*t210;
+              const double t4312 = -2.0*t1864-t1865-t1866+t1869+t739*t4306-t1873+t4308-t4309-t1878-t1881+t4310+t443*t622;
+              const double t4313 = t328*t279;
+              const double t4315 = 2.0*t1889;
+              const double t4316 = 2.0*t1891;
+              const double t4317 = 3.0*t1892;
+              const double t4319 = 2.0*t476*t661;
+              const double t4320 = 3.0*t1908;
+              const double t4321 = -t4313+2.0*t1883+t4315-t4316+t4317-t1895+t1897+t1904-t4319-t1907+t4320+t1911;
+              const double t4327 = 2.0*t1927;
+              const double t4328 = 2.0*t1936;
+              const double t4329 = t586*t279;
+              const double t4330 = 2.0*t1940;
+              const double t4331 = 2.0*t1943;
+              const double t4332 = -t1914-2.0*t1915+2.0*t233*t1447+t4327-t1930+t1931-t4328+t4329-t4330+t1942-t4331-t1944;
+              const double t4333 = t586*t3565;
+              const double t4334 = t638*t230;
+              const double t4335 = t1365*t204;
+              const double t4337 = 2.0*t1365*t976;
+              const double t4343 = -t4333+t1948-t4334-t4335-t4337+t1955+2.0*t1774*t187-t1956+t1958-2.0*t252*t1258+t1961-t1252*t187;
+              const double t4345 = 2.0*t1962;
+              const double t4346 = 2.0*t1966;
+              const double t4350 = t559*vertices[3](1);
+              const double t4353 = 2.0*t1989;
+              const double t4354 = t4345+t4346+2.0*t1968-2.0*t1970+t290*t3725-t1973-t739*t4350-t739*t733-t1980+t1981+t1984+t4353;
+              const double t4360 = 2.0*t2010;
+              const double t4361 = t100*zeta;
+              const double t4366 = 2.0*t2004-2.0*t2005-t2006-2.0*t453*t4018-2.0*t2009+t4360-t341*t4361-t2016+t2017+t341*t100-t443*t1300-t443*t352;
+              const double t4374 = 2.0*t2023;
+              const double t4375 = 3.0*t2025;
+              const double t4376 = 3.0*t2027;
+              const double t4377 = 2.0*t2029;
+              const double t4378 = 2.0*t2034;
+              const double t4379 = -2.0*t2020+t4374+t4375-t4376+t4377-t2030+t2032+t2033+t4378-t2035-t2037;
+              const double t4380 = 3.0*t2038;
+              const double t4383 = 2.0*t2046;
+              const double t4385 = 2.0*t2062;
+              const double t4386 = -t4380+2.0*t2040+t2041-t739*t400-t2044+t4383-t2057-t2059+t739*t1258-t2061+t4385+t2066;
+              const double t4389 = t2068-t2069+t2070-t2071-t2075+t2076-t2077+t2079-t2084+t2085+2.0*t2086-t2088;
+              const double t4390 = 3.0*t2094;
+              const double t4395 = t674*vertices[7](2);
+              const double t4397 = t674*vertices[4](2);
+              const double t4401 = t2089-t4390+t2101+t443*t461+2.0*t2105-2.0*t2106-2.0*t2108-t2110+t156*t4395-t156*t4397-2.0*t2112-t140*t4395;
+              const double t4411 = t831*t499;
+              const double t4415 = t2123+t824*t3995+t140*t4397-2.0*t1680*t661+t792*t275-t2136-t2138+2.0*t792*t160-t4411-t824*t2853+2.0*t736*t56;
+              const double t4416 = t768*t196;
+              const double t4418 = 2.0*t2147;
+              const double t4419 = t782*vertices[6](2);
+              const double t4421 = t8*vertices[5](2);
+              const double t4423 = t782*vertices[5](2);
+              const double t4433 = 2.0*t4416+t4418-t620*t4419-t720*t4421+t620*t4423-2.0*t792*t56-t2155+t341*t4-t290*t3759+t290*t3816-t290*t3723+2.0*t2265*t661;
+              const double t4437 = t88*zeta;
+              const double t4446 = t2166+t2168+2.0*t292*t138+2.0*t290*t4437+2.0*t2177+2.0*t290*t19+t824*t3966-t2183-t824*t3935-t2189-t2195-t290*t88;
+              const double t4448 = t429*vertices[5](2);
+              const double t4457 = 2.0*t2527*t477;
+              const double t4458 = t469*t222;
+              const double t4459 = t765*t210;
+              const double t4460 = t720*t145+t778*t4448-t720*t4437-t290*t275+t736*t88-t2201+2.0*t2202+t674*t143-t674*t55-t4457-t4458-t4459;
+              const double t4464 = t595*t230;
+              const double t4467 = 2.0*t2212;
+              const double t4468 = 2.0*t2213;
+              const double t4470 = 2.0*t2536*t477;
+              const double t4471 = 2.0*t2219;
+              const double t4476 = t4464-2.0*t290*t62-t4467+t4468+t4470-t2218-t4471+2.0*t828*t62+t824*t609+t824*t860-t2225;
+              const double t4477 = t464*vertices[1](2);
+              const double t4480 = 2.0*t2230;
+              const double t4481 = 2.0*t2231;
+              const double t4482 = 2.0*t2233;
+              const double t4483 = 2.0*t2243;
+              const double t4485 = 2.0*t2249;
+              const double t4486 = 2.0*t2253;
+              const double t4487 = t2227+t2229+2.0*t156*t4477+t4480+t4481+t4482-t2242+t4483-t824*t3914+t2248-t4485-t4486;
+              const double t4490 = 2.0*t469*t747;
+              const double t4491 = t860*vertices[4](1);
+              const double t4493 = t727*vertices[7](2);
+              const double t4497 = 2.0*t2278;
+              const double t4498 = t2256-t4490+t4491-t2261+2.0*t2262+t2264+t2270-t156*t4493+t2272+t2277-2.0*t560*t23+t4497;
+              const double t4499 = 2.0*t2279;
+              const double t4501 = t727*vertices[4](2);
+              const double t4505 = t429*vertices[1](2);
+              const double t4509 = -t4499+t2281-4.0*t2285+t156*t4501-t2291+t2294-t824*t4050-t393*t1447-t2303-t778*t4505-2.0*t560*t62-t2311;
+              const double t4516 = t300*vertices[5](1);
+              const double t4517 = t334*eta;
+              const double t4519 = 2.0*t4517*t976;
+              const double t4525 = -t778*t4287+2.0*t560*t160-t2317+t778*t3961+t4516+t4519+t140*t4493-t140*t4501+t341*t119+t290*t274+t290*t154;
+              const double t4526 = t650*vertices[6](1);
+              const double t4530 = t650*vertices[5](1);
+              const double t4537 = 2.0*t2339;
+              const double t4538 = t233*t4526-t290*t119-t341*t98-t233*t4530+t290*t3-t290*t1+t358*t140-t292*t140+t290*t20-t2327+t2338-t4537;
+              const double t4540 = t3972*vertices[0](1);
+              const double t4543 = t559*vertices[3](2);
+              const double t4545 = t489*vertices[2](2);
+              const double t4546 = t290*vertices[0](2);
+              const double t4551 = t2342+t393*t4540-t2345+t1635*vertices[0](2)+t2351+t679*t4543+t4545+t2361+t679*t4546+t2365+t824*t4298+2.0*t18*t3969;
+              const double t4558 = t449*vertices[5](1);
+              const double t4560 = t1300*eta;
+              const double t4562 = 2.0*t2395;
+              const double t4564 = -2.0*t2376+2.0*t958*t196-t341*t3-2.0*t2378+t2379+2.0*t2386+t233*t4558-t2389-t679*t4560-t4562+t393*t2662-t2399;
+              const double t4569 = 2.0*t2401;
+              const double t4572 = t559*vertices[0](2);
+              const double t4575 = t1365*vertices[4](2);
+              const double t4576 = t1365*t196;
+              const double t4578 = t3972*vertices[4](1);
+              const double t4581 = 2.0*t1232*t747;
+              const double t4582 = t4569+4.0*t2403-t1635*vertices[3](2)-t679*t4572-t679*t3864-t4575+t2409-2.0*t4576-t393*t4578+t4581+t2418;
+              const double t4586 = 2.0*t483*t13;
+              const double t4589 = t930*vertices[1](2);
+              const double t4591 = t119*zeta;
+              const double t4594 = t2363*vertices[5](2);
+              const double t4598 = t2419+t1379*t4361-t1774*t204-t4586+2.0*t290*t29+t290*t4589-t341*t4591+t2434-t727*t137+t2437-t736*t4594-2.0*t290*t152;
+              const double t4602 = t2363*vertices[1](2);
+              const double t4606 = t143*eta;
+              const double t4612 = t480*vertices[1](2);
+              const double t4615 = 2.0*t2464;
+              const double t4617 = -t2439+2.0*t2440-t309*vertices[5](2)+t736*t4602-2.0*t295*t976+t727*t4606-t727*t56-2.0*t252*t4517+2.0*t2457-2.0*t18*t4612+t4615-t377*t3917;
+              const double t4620 = t449*vertices[6](1);
+              const double t4623 = 2.0*t484*t13;
+              const double t4625 = 2.0*t3076*t1180;
+              const double t4628 = t606*vertices[3](1);
+              const double t4632 = 2.0*t252*t3837-t2466-t2468-t233*t4620+t4623+t4625+2.0*t156*t4505-t4628+t2497-2.0*t156*t3798-t2510-t824*t1029;
+              const double t4637 = 2.0*t2515;
+              const double t4638 = t606*t15;
+              const double t4640 = t324*t860;
+              const double t4645 = t328*vertices[5](2);
+              const double t4646 = 2.0*t317*t976-t4637-t2526-2.0*t4638-t4640+t2531+t2535-2.0*t290*t21-t792*t274-t441*t252-t4645;
+              const double t4653 = 2.0*t2565;
+              const double t4654 = 2.0*t2567;
+              const double t4656 = 2.0*t1447*t1180;
+              const double t4657 = 2.0*t1386*t130+t2543+t2547-2.0*t1418*t747+t2550-2.0*t2555+2.0*t2558-t2562-t4653+t4654-t2570+t4656;
+              const double t4660 = 2.0*t736*t11;
+              const double t4663 = 2.0*t2265*t477;
+              const double t4667 = 2.0*t2615;
+              const double t4671 = 2.0*t2623;
+              const double t4672 = t4660-t2587+t2596-2.0*t2598-t4663-2.0*t290*t3738+t2610-t140*t3983-t4667+2.0*t2618+2.0*t290*t4591+t4671;
+              const double t4676 = t792*vertices[3](2);
+              const double t4680 = vertices[1](0)*vertices[7](2);
+              const double t4681 = t4680*zeta;
+              const double t4683 = vertices[5](0)*vertices[7](2);
+              const double t4684 = t4683*zeta;
+              const double t4686 = t2624+t2629+2.0*t2631+t140*t3987-t140*t3945-t2633-t778*t4676+2.0*t3100*t747+t2637+t778*t4681+t2646-t778*t4684;
+              const double t4693 = t341*vertices[3](1);
+              const double t4696 = t635*t179;
+              const double t4700 = 2.0*t751*t1180;
+              const double t4702 = 2.0*t2292*t976;
+              const double t4703 = -2.0*t3100*t669+t2657+t824*t3917+t252*t4693-t824*t3867+2.0*t4696-t2669-2.0*t2670-t4700-t2674-t4702;
+              const double t4707 = 2.0*t2648*t1180;
+              const double t4708 = 2.0*t2700;
+              const double t4710 = -t2678+2.0*t290*t2+t2680+t2682-t2684-t2687+t2689+t4707+t2695-t2699+t4708+2.0*t2702;
+              const double t4715 = 2.0*t2124*t477;
+              const double t4717 = 2.0*t2124*t1945;
+              const double t4720 = 2.0*t779*t96;
+              const double t4724 = 2.0*t1140*t661;
+              const double t4726 = 2.0*t290*t158-t2705+t4715-t4717-t2710+t393*t1365+t4720+t334*t279-t727*t64+t2714-t4724+t341*t99;
+              const double t4730 = 2.0*t1244*t976;
+              const double t4732 = 2.0*t1418*t531;
+              const double t4733 = t638*t252;
+              const double t4735 = 2.0*t736*t74;
+              const double t4736 = -2.0*t290*t9+t4730+t4732+t4733-t2725-t2727-t2728-t2729+t2730-t4735+t2731+t2734;
+              const double t4740 = 2.0*t2662*t1180;
+              const double t4743 = vertices[6](0)*vertices[4](1);
+              const double t4746 = 2.0*t2187*t11;
+              const double t4748 = 2.0*t426*t1180;
+              const double t4749 = -t2735-t2737+t2739-t2741-t4740-2.0*t560*t130+t393*t4743-t4746+t2749+t2754-t4748;
+              const double t4752 = 2.0*t2022*t57;
+              const double t4754 = 2.0*t2022*t65;
+              const double t4756 = t2759+t2762+t341*t275-t4752+t2764+t2766-t2768+t4754-t2774-t341*t274-t2776-t2778;
+              const double t4759 = 2.0*t2482*t477;
+              const double t4763 = 2.0*t2482*t1945;
+              const double t4764 = 2.0*t2792;
+              const double t4768 = 2.0*t1562*t120;
+              const double t4770 = 2.0*t2811;
+              const double t4772 = 2.0*t586*t661;
+              const double t4773 = -t4759-t2783+t2786+2.0*t1193*t321+t4763-t4764-2.0*t290*t3681+t2803-t4768-t341*t4207-t4770+t4772;
+              const double t4777 = 2.0*t1859*t531;
+              const double t4784 = 2.0*t560*t42;
+              const double t4785 = t341*t3883-2.0*t2821-t4777-2.0*t2823-t2825-2.0*t290*t4+t2828+t2831-t2832-2.0*t453*t606+t4784+t2850;
+              const double t4792 = 2.0*t560*t57;
+              const double t4796 = 2.0*t560*t13;
+              const double t4797 = 2.0*t2876;
+              const double t4800 = -t4792+2.0*t2862-t393*t476+t4796-t2866-t2868+t2870-t2873+t4797+2.0*t453*t352-t2885;
+              const double t4802 = 2.0*t560*t106;
+              const double t4804 = 2.0*t2891;
+              const double t4806 = 2.0*t560*t110;
+              const double t4807 = t1485*vertices[2](2);
+              const double t4809 = 2.0*t2901;
+              const double t4811 = t1485*vertices[1](2);
+              const double t4815 = -t4802-t495*t8+t4804-t2893-t4806+t2898+t290*t4807-t4809-2.0*t2902-t290*t4811-2.0*t2905+t739*t383;
+              const double t4818 = 2.0*t560*t115;
+              const double t4820 = 2.0*t560*t120;
+              const double t4822 = 2.0*t1734*t976;
+              const double t4823 = 2.0*t2923;
+              const double t4825 = t635*t165;
+              const double t4827 = 2.0*t2187*t74;
+              const double t4830 = t930*vertices[2](2);
+              const double t4832 = t4818+t2912-t4820+t2919-t4822+t4823+2.0*t2925+t4825+t4827+2.0*t2930-2.0*t2931-t290*t4830;
+              const double t4839 = 2.0*t1258*t976;
+              const double t4841 = 2.0*t560*t81;
+              const double t4844 = 2.0*t560*t84;
+              const double t4846 = 2.0*t560*t89;
+              const double t4847 = 2.0*t2932+2.0*t2933-t739*t390-2.0*t2934-t2936-2.0*t2937+t4839-t4841-t349*t606+t4844+t4846+t2954;
+              const double t4852 = 2.0*t560*t92;
+              const double t4855 = 2.0*t828*t92;
+              const double t4857 = 2.0*t156*t562;
+              const double t4858 = -t2957+t349*t352-t4852+t2962-t2964+t2969-t2973+t18*t606+t4855+t4857-t2993;
+              const double t4863 = 2.0*t290*t115;
+              const double t4865 = 2.0*t560*t11;
+              const double t4867 = 2.0*t560*t16;
+              const double t4869 = 2.0*t828*t115;
+              const double t4871 = -t18*t352-t323*t156-t2997+t18*t4134+t4863+t3007+t3008+t4865+t4867-t4869-t377*t461+t3024;
+              const double t4873 = 2.0*t3029;
+              const double t4875 = 2.0*t560*t38;
+              const double t4877 = 2.0*t2527*t1180;
+              const double t4878 = t3026-t3027+t4873-t4875-t3037-t3039-t3041+t3043+t3045+t3047-t4877-t3049;
+              const double t4880 = 2.0*t3100*t1255;
+              const double t4881 = t606*t51;
+              const double t4883 = 2.0*t560*t72;
+              const double t4886 = 2.0*t400*t976;
+              const double t4890 = 2.0*t560*t74;
+              const double t4892 = 2.0*t514*t1180;
+              const double t4894 = 2.0*t2619*t531;
+              const double t4896 = 2.0*t290*t92;
+              const double t4897 = t3051+t4880-t4881+t4883+t323*t18-t4886-2.0*t3083+t739*t765-t4890+t4892+t4894-t4896;
+              const double t4901 = 2.0*t3097;
+              const double t4903 = 2.0*t2619*t1255;
+              const double t4906 = 2.0*t560*t96;
+              const double t4910 = t4901-t4903+t377*t1029-t4906-t3125-t3126-t3128-2.0*t736*t23-t424*t4540+t3135-t3139;
+              const double t4912 = 2.0*t3144;
+              const double t4913 = t3141+t559*t4811-t3143+t4912+t3150-t3151+t3152+t3155+t3160-t3165+t3166-t3168;
+              const double t4917 = 2.0*t3100*t531;
+              const double t4919 = t3170-t3171-t3172+t3175+t559*t4830+t3176+t3177+t3184-t4917-t3186-t559*t4589+t3187;
+              const double t4921 = 2.0*t708*t976;
+              const double t4925 = 2.0*t560*t65;
+              const double t4926 = 2.0*t3203;
+              const double t4928 = 2.0*t3837*t976;
+              const double t4930 = 2.0*t18*t2145;
+              const double t4932 = 2.0*t508*t623;
+              const double t4934 = 2.0*t489*t747;
+              const double t4935 = t3188+t4921+2.0*t1774*t661+t4925-t3202-t4926-t3206-t4928-t4930-t4932+t4934+t3221;
+              const double t4941 = 2.0*t765*t747;
+              const double t4942 = 2.0*t3233;
+              const double t4943 = 2.0*t3242;
+              const double t4944 = 2.0*t3250;
+              const double t4945 = 2.0*t3254;
+              const double t4949 = 2.0*t252*t2292-t4941+t4942+t3236+t3240-t4943+t3245+t4944+t4945-2.0*t2124*t661-t424*t2662;
+              const double t4958 = t727*vertices[7](1);
+              const double t4961 = t697*t2593+t424*t4578-2.0*t1252*t661+2.0*t2124*t591-t697*t2584+t424*t1447-t222*t4958+t3259-t3261+2.0*t3262-t3263+t3265;
+              const double t4963 = 2.0*t3273;
+              const double t4964 = 2.0*t3274;
+              const double t4971 = t1379*vertices[3](1);
+              const double t4977 = -t3271-t4963-t4964-2.0*t736*t102+t3281+t3283+2.0*t1252*t747+t3284+2.0*t620*t278-t252*t4971+2.0*t620*t4-2.0*t620*t158;
+              const double t4978 = t711*vertices[2](1);
+              const double t4980 = t603*vertices[2](1);
+              const double t4982 = t603*vertices[1](1);
+              const double t4990 = -t222*t4978-t230*t4980-t222*t4982+t230*t3627+t3290-t3291-t3292+2.0*t620*t3681-2.0*t620*t34+t1379*t4591-t3294+t3296;
+              const double t5002 = 2.0*t3307;
+              const double t5006 = 2.0*t733*t1180;
+              const double t5007 = t3299-2.0*t792*t130-t1379*t99-2.0*t620*t130+t3302-t3304-2.0*t792*t159+t5002+t697*t1307+2.0*t3312-t5006;
+              const double t5008 = 2.0*t3314;
+              const double t5009 = t429*vertices[5](1);
+              const double t5017 = t3777*vertices[3](1);
+              const double t5019 = t2239*zeta;
+              const double t5021 = -t5008+t3317-t697*t5009+2.0*t736*t6+t3325+2.0*t620*t150-t3329+t222*t4980-t559*t4807-t697*t5017+t697*t5019+t3332;
+              const double t5028 = 2.0*t831*t409;
+              const double t5033 = t836*vertices[5](1);
+              const double t5035 = t3333-t739*t1859+t424*t3076+t739*t3114+t424*t2536+t5028-t424*t2527-t424*t4293+2.0*t3334+t230*t4982+t3337+t252*t5033;
+              const double t5039 = t727*vertices[4](1);
+              const double t5042 = t711*vertices[1](1);
+              const double t5045 = -t3345-t3346-t697*t1794+t697*t2273+t230*t4958-t230*t5039+t230*t4978+t222*t5042-t230*t5042+t3347-t3348+t3349;
+              const double t5049 = t836*vertices[1](1);
+              const double t5059 = 2.0*t860*t817;
+              const double t5061 = -t3351+4.0*t3352-t252*t5049+2.0*t230*t2662-2.0*t230*t2648+t230*t1365-t424*t765-t479*t635+t5059+t3360+t222*t3625;
+              const double t5064 = 2.0*t3367;
+              const double t5066 = 2.0*t3371;
+              const double t5071 = 2.0*t3376;
+              const double t5073 = 2.0*t560*t6+t5064+t156*t4050-t5066+t824*t4229-t156*t860+t156*t358-t3374-t156*t3952+t5071+t156*t330-t3377;
+              const double t5075 = 2.0*t3379;
+              const double t5077 = t140*zeta;
+              const double t5079 = 2.0*t5077*t353;
+              const double t5080 = 2.0*t3399;
+              const double t5081 = t3378-t5075+t3381-t3382+2.0*t3387+t3388-t3390-t5079+t3393-t5080-t3405+t3406;
+              const double t5082 = 2.0*t3408;
+              const double t5085 = 2.0*t5077*t1030;
+              const double t5087 = 2.0*t5077*t806;
+              const double t5089 = 2.0*t5077*t610;
+              const double t5091 = 2.0*t5077*t517;
+              const double t5092 = -t3407+t5082+t3410+t824*t461-t3414+t3418+t3423-t3424+t5085+t5087-t5089-t5091;
+              const double t5096 = 2.0*t3426;
+              const double t5098 = 2.0*t5077*t623;
+              const double t5100 = 2.0*t3433;
+              const double t5101 = 2.0*t3436;
+              const double t5102 = 2.0*t3438;
+              const double t5103 = 2.0*t3442;
+              const double t5104 = t5096+t5098-t309*t279+t3428-t3430-t5100-t5101-t5102-t5103+t3445+t3446;
+              const double t5105 = t586*vertices[5](2);
+              const double t5108 = 2.0*t3457;
+              const double t5110 = 2.0*t3464;
+              const double t5111 = 2.0*t3465;
+              const double t5113 = t5105-2.0*t3448+t3449+t222*t5039-t3452-t3456-t5108-t3461+t923*t230-t5110-t5111+4.0*t3469;
+              const double t5116 = 2.0*t1562*t16;
+              const double t5120 = 2.0*t3629*t1180;
+              const double t5128 = t779*t284;
+              const double t5129 = t5116+t679*t352-t3475-t679*t622-t5120+t727*t55+t360*t230+2.0*t360*t3565-t360*t279-t727*t143-t736*t55+t5128;
+              const double t5134 = t595*t252;
+              const double t5135 = t483*t3;
+              const double t5136 = t733*t179;
+              const double t5138 = t733*t165;
+              const double t5139 = t765*t187;
+              const double t5140 = t768*t187;
+              const double t5146 = -2.0*t1774*t196+2.0*t908*t179-t5134+t5135-2.0*t5136-t5138+t5139-t5140+t252*t3612+2.0*t792*t273-t1379*t119+t1379*t98;
+              const double t5165 = -2.0*t792*t64-t620*t64+t620*t273-2.0*t620*t3-2.0*t792*t284-2.0*t620*t274-t620*t284+t792*t119+t736*t284-t736*t273+t736*t1-t736*t154;
+              const double t5167 = t300*t147;
+              const double t5182 = t736*t64+t5167+2.0*t337*t3531-t337*t222+t864*t252+2.0*t1193*t15+t424*t4093-t424*t1365+2.0*t1193*t614-t424*t4743-2.0*t1193*t499+t424*t476;
+              const double t5193 = t444*t156;
+              const double t5196 = -t739*t476-t739*t3612+t255*t768+t739*t635-t230*t768+t362*t499-t362*t614-t424*t568-t252*t360+t5193-t252*t635+t424*t1075;
+              const double t5198 = t860*t8;
+              const double t5199 = t831*t324;
+              const double t5209 = 2.0*t3480;
+              const double t5211 = 2.0*t3114*t976;
+              const double t5212 = t739*t3732+t5198+t5199+t233*t635+2.0*t233*t4093-2.0*t233*t1365-t233*t733-2.0*t233*t568-t230*t4093-t5209+t5211-t3483;
+      s1 = t5104+t4354+t3734+t4366+t3617+t5073+t4446+t5081+t4672+t3999+t3632+t4379+t3766+t4460+t3647+t4386+t3806+t4476+t5092+t5212+t4389+t3810+t4487+t3659+t3823+t4871+t4401+t5165+t4509+t4007+t3854+t5113+t4538+t3673+t4800+t3863+t4415+t3872+t3878+t4188+t3687+t4343+t4149+t4564+t4686+t3699+t3895+t5061+t5129+t4433+t3714+t3906+t4897+t4703+t4024+t4120+t4035+t5146+t4832+t3930+t4202+t4163+t4598+t4046;
+              const double t5219 = s1+t4710+t3753+t4498+t3939+t4055+t4525+t4258+t3781+t4726+t3796+t3957+t3975+t4131+t4332+t4551+t4632+t3842+t5182+t4066+t4176+t4736+t4847+t5196+t3985+t4075+t4582+t4082+t3888+t4815+t4749+t4088+t4646+t3920+t4099+t4858+t4756+t4110+t4657+t4215+t4773+t4617+t4225+t4238+t4878+t4785+t4248+t4270+t4280+t4295+t4303+t4312+t4321+t4910+t4913+t4919+t4935+t4949+t4961+t4977+t4990+t5007+t5021+t5035+t5045;
+              const double t5223 = 2.0*t395*t230;
+              const double t5224 = t464*vertices[5](2);
+              const double t5226 = t3972*vertices[3](2);
+              const double t5227 = t4683*eta;
+              const double t5228 = vertices[2](0)*vertices[7](2);
+              const double t5229 = t5228*zeta;
+              const double t5230 = t559*vertices[4](2);
+              const double t5231 = t1300*zeta;
+              const double t5232 = vertices[2](0)*eta;
+              const double t5233 = t5232*vertices[4](2);
+              const double t5234 = t5232*vertices[0](2);
+              const double t5235 = t5223-t3867+2.0*t5224-t5226+t4298-t5227+t3964-t3793+t5229+t5230-t4572+t3787+t4018+t5231-t4287-t5233+t5234+t3899-t3778;
+              const double t5236 = t609*eta;
+              const double t5237 = t2853*eta;
+              const double t5238 = 2.0*t947;
+              const double t5239 = t480*vertices[2](2);
+              const double t5241 = 2.0*t353;
+              const double t5242 = 2.0*t4612;
+              const double t5243 = 2.0*t465;
+              const double t5244 = 2.0*t3223;
+              const double t5245 = 2.0*t888;
+              const double t5246 = 2.0*t1905;
+              const double t5247 = 2.0*t1902;
+              const double t5248 = t5236-t5237+t5238-2.0*t5239+t5241-t352-t3989+t4505+t5242+t3953+t5243+t4050-t5244+t5245+t4043+t3914-t5246+t4134+t5247;
+              const double t5250 = 2.0*t1888;
+              const double t5251 = 2.0*t1876;
+              const double t5252 = 2.0*t517;
+              const double t5253 = 2.0*t510;
+              const double t5255 = 2.0*t1082;
+              const double t5257 = 2.0*t562;
+              const double t5258 = 2.0*t1935;
+              const double t5259 = 2.0*t806;
+              const double t5261 = 2.0*t1164;
+              const double t5262 = 2.0*t4477;
+              const double t5263 = 2.0*t1030;
+              const double t5264 = 2.0*t455;
+              const double t5265 = t5250+t606-t5251+t5252+t5253-2.0*t623-t5255-2.0*t467-t5257-t5258-t5259+2.0*t610+t5261-t3947-t5262-t5263-t4681+t5264-t4021;
+              const double t5266 = vertices[1](0)*vertices[2](2);
+              const double t5267 = t5266*xi;
+              const double t5269 = 2.0*t647;
+              const double t5271 = t4680*eta;
+              const double t5272 = t395*t255;
+              const double t5273 = 2.0*t5272;
+              const double t5274 = t290*t179;
+              const double t5275 = 2.0*t5274;
+              const double t5276 = 2.0*t1668;
+              const double t5277 = t429*t162;
+              const double t5278 = 2.0*t5277;
+              const double t5279 = t395*t233;
+              const double t5280 = 2.0*t5279;
+              const double t5281 = t429*t179;
+              const double t5282 = 2.0*t5281;
+              const double t5283 = t429*t176;
+              const double t5284 = 2.0*t5283;
+              const double t5285 = t480*t165;
+              const double t5286 = 2.0*t5285;
+              const double t5287 = 2.0*t1202;
+              const double t5288 = 2.0*t437;
+              const double t5290 = 2.0*t454*t123;
+              const double t5291 = t461*t123;
+              const double t5292 = 2.0*t5291;
+              const double t5293 = t480*t168;
+              const double t5294 = 2.0*t5293;
+              const double t5295 = 2.0*t5267-t4135-t5269-2.0*t1178+t5271+t5273+t5275+t5276+t3864-t3966+t5278-t5280+t5282-t5284+t5286+t5287-t5288-t5290-t5292-t5294;
+              const double t5298 = t429*t174;
+              const double t5299 = t1029*t123;
+              const double t5300 = vertices[1](0)*vertices[5](2);
+              const double t5301 = t5300*xi;
+              const double t5302 = t523*t179;
+              const double t5303 = t523*t174;
+              const double t5304 = t705*t165;
+              const double t5305 = t523*t162;
+              const double t5306 = t523*t176;
+              const double t5307 = t705*t168;
+              const double t5308 = t464*t230;
+              const double t5309 = t736*t196;
+              const double t5310 = t5300*t183;
+              const double t5311 = vertices[1](0)*vertices[6](2);
+              const double t5312 = t5311*t183;
+              const double t5313 = t480*t255;
+              const double t5314 = t480*t252;
+              const double t5315 = t395*t189;
+              const double t5316 = t395*t187;
+              const double t5317 = -t5298+t5299-t5301-t5302+t5303-t5304-t5305+t5306+t5307+t1027+t300-t5308-t5309+t5310-t5312-t5313+t5314+t5315-t5316;
+              const double t5318 = t464*t279;
+              const double t5319 = t480*t222;
+              const double t5320 = t395*t252;
+              const double t5321 = t464*t206;
+              const double t5322 = t979*t196;
+              const double t5323 = t412*t162;
+              const double t5324 = t979*t176;
+              const double t5325 = t979*t198;
+              const double t5326 = t464*t204;
+              const double t5327 = t979*t162;
+              const double t5328 = t2145-t454-t509+t5318-t5319-t5320+t5321+t850+t5322-t5323-t848-t5324-t5325-t1182+t1160-t5326+t5327-t1203+t3096;
+              const double t5330 = t412*t176;
+              const double t5331 = t412*t198;
+              const double t5332 = t464*t189;
+              const double t5333 = t887*t183;
+              const double t5334 = t412*t196;
+              const double t5335 = t1202*t183;
+              const double t5336 = t352*t183;
+              const double t5337 = t461*t183;
+              const double t5338 = t1300*t183;
+              const double t5339 = t788*t183;
+              const double t5340 = t622*t183;
+              const double t5341 = t464*t187;
+              const double t5342 = t509*t183;
+              const double t5343 = t705*t206;
+              const double t5344 = t705*t204;
+              const double t5345 = t2853*t123;
+              const double t5346 = t1191+t5330+t5331-t5332-t5333-t5334+t5335-t5336+t5337-t5338+t5339-t1937+t5340+t5341-t5342-t5343+t5344-t2763+t5345;
+              const double t5348 = 2.0*t1772*t123;
+              const double t5349 = t1027*t123;
+              const double t5350 = 2.0*t5349;
+              const double t5351 = t609*t123;
+              const double t5352 = 2.0*t5351;
+              const double t5353 = t395*t210;
+              const double t5354 = 2.0*t5353;
+              const double t5355 = t395*t212;
+              const double t5356 = 2.0*t5355;
+              const double t5357 = t887*t123;
+              const double t5358 = 2.0*t5357;
+              const double t5359 = t480*t212;
+              const double t5360 = 2.0*t5359;
+              const double t5361 = t480*t210;
+              const double t5362 = 2.0*t5361;
+              const double t5364 = 2.0*t5266*t123;
+              const double t5365 = t5311*t123;
+              const double t5366 = 2.0*t5365;
+              const double t5368 = 2.0*t464*t233;
+              const double t5369 = -t5348+t5350-t5352+t5354+t622-t5356+t5358+t5360-t5362-t860-t4060-t5364+t5366+t5368-t3798-t609+t1029+t358-t330-t3952;
+              const double t5375 = vertices[6](0)*t302;
+              const double t5383 = t1976*vertices[3](2);
+              const double t5384 = t1976*vertices[2](2);
+              const double t5385 = -t1990*t210-t5375*t212+t429*t3522-t429*t3520+t5375*t255-t5375*t252+t5375*t210+t1990*t3531-t5383+t5384-t1977;
+              const double t5386 = vertices[1](0)*t302;
+              const double t5387 = t5386*vertices[3](2);
+              const double t5388 = t5386*vertices[2](2);
+              const double t5391 = t1990*vertices[3](2);
+              const double t5392 = t1990*vertices[2](2);
+              const double t5396 = t1997-t5387+t5388+t429*t1167-t429*t1150+t5391-t5392-t1990*t168-t1990*t222+t1990*t165+t2500;
+              const double t5398 = t3031*vertices[5](2);
+              const double t5399 = t3031*vertices[4](2);
+              const double t5400 = t1785*vertices[5](2);
+              const double t5401 = t1785*vertices[4](2);
+              const double t5402 = t5386*vertices[5](2);
+              const double t5403 = t5386*vertices[4](2);
+              const double t5404 = -t1991-t5398+t5399+t3034-t3032+t5400-t5401-t1786+t2856-t5402+t5403;
+              const double t5405 = vertices[0](0)*t302;
+              const double t5406 = t5405*vertices[5](2);
+              const double t5410 = t5405*vertices[2](2);
+              const double t5417 = t5406+t5386*t168+t5386*t222-t1976*t3531-t5410+t1976*t210+t1976*t168+t1976*t222-t1976*t165-t1976*t212+t1976*t255;
+              const double t5423 = t5405*vertices[3](2);
+              const double t5431 = -t1976*t252+t5405*t165-t5386*t3531+t5423-t5386*t165+t1785*t233-t1785*t230+t1785*t187+t1785*t206-t1785*t3565+t1785*t279;
+              const double t5443 = -t1785*t204-t1785*t189-t412*t3522+t412*t3520+t3031*t230+t5375*t189-t5375*t233-t5375*t187+t5375*t230+t3031*t204-t3031*t233;
+              const double t5451 = t5405*vertices[4](2);
+              const double t5456 = -t3031*t187+t3031*t189+t3031*t3565+t5386*t204-t3031*t279-t3031*t206-t5451-t5386*t206+t5386*t3565-t5386*t279-t5405*t3565;
+              const double t5464 = t5405*t279-t5405*t204+t5405*t206+t412*t1523-t412*t917-t947+t5405*t3531-t5405*t168-t353-t465+t5244;
+              const double t5470 = -t888+t1905-t1902-t1888+t1876-t517-t5253+t623+t1082+t1990*t212-t1990*t255;
+              const double t5473 = t1990*t252-t5405*t222+t467+t5257+t1935+t806-t610-t5261+t1030-t455+t647;
+              const double t5475 = t1178-t1668-t5278-t5281+t5283-t5285-t1202+t437+t5290+t5291+t5293;
+              const double t5476 = 2.0*t5298;
+              const double t5477 = 2.0*t5303;
+              const double t5478 = 2.0*t5305;
+              const double t5479 = t5476-t5299+t5302-t5477+t5304+t5478-t5306-t5307-t1027-t300-t5315;
+              const double t5482 = 2.0*t2145;
+              const double t5483 = 2.0*t5323;
+              const double t5484 = 2.0*t5325;
+              const double t5485 = t5316-t5482+t454+t509-t5321-t850-t5322+t5483+t848+t5324+t5484;
+              const double t5486 = 2.0*t5327;
+              const double t5487 = 2.0*t5331;
+              const double t5488 = 2.0*t5333;
+              const double t5489 = t1182-t1160+t5326-t5486+t1203-t3096-t1191-t5330-t5487+t5332+t5488;
+              const double t5491 = 2.0*t5335;
+              const double t5492 = 2.0*t5339;
+              const double t5493 = 2.0*t1937;
+              const double t5494 = 2.0*t5342;
+              const double t5495 = t5334-t5491+t5336-t5337+t5338-t5492+t5493-t5340-t5341+t5494+t5343;
+              const double t5496 = -t5344+t2763-t5345+t5348-t5350+t5351-t5353+t5355-t5358-t5359+t5361;
+              const double t5501 = (t5385+t5396+t5404+t5417+t5431+t5443+t5456+t5464+t5470+t5473+t5475+t5479+t5485+t5489+t5495+t5496)*t3605;
+              const double t5504 = t469*xi;
+              const double t5505 = 2.0*t5504;
+              const double t5506 = 2.0*t1318;
+              const double t5508 = 2.0*t980;
+              const double t5509 = 2.0*t643;
+              const double t5510 = 2.0*t843;
+              const double t5511 = 2.0*t868;
+              const double t5512 = t1774*xi;
+              const double t5513 = 2.0*t5512;
+              const double t5514 = 2.0*t822;
+              const double t5515 = t559*vertices[4](1);
+              const double t5516 = t464*vertices[5](1);
+              const double t5518 = t480*vertices[1](1);
+              const double t5519 = 2.0*t5518;
+              const double t5520 = t5505-t5506-2.0*t569-t5508+t5509-t5510-t5511-t5513+t1794+t5514-t1653-t5515+t4306-t2482+t2593-2.0*t5516-t1307-t5519-t3076;
+              const double t5522 = t908*xi;
+              const double t5523 = 2.0*t5522;
+              const double t5524 = 2.0*t655;
+              const double t5525 = 2.0*t1734;
+              const double t5526 = t480*vertices[2](1);
+              const double t5528 = t489*xi;
+              const double t5529 = 2.0*t5528;
+              const double t5530 = 2.0*t1847;
+              const double t5531 = t586*xi;
+              const double t5532 = 2.0*t5531;
+              const double t5533 = 2.0*t1244;
+              const double t5534 = 2.0*t769;
+              const double t5535 = 2.0*t751;
+              const double t5536 = 2.0*t629;
+              const double t5537 = 2.0*t683;
+              const double t5538 = 2.0*t853;
+              const double t5539 = t417*xi;
+              const double t5540 = 2.0*t5539;
+              const double t5541 = t3629-2.0*t970+t2662+t5523-t2648+t5524+t5525+2.0*t5526-t5529+t5530-t5532-t5533+t5534+t5535+t5536-t5537-t5538+t5540-t1258;
+              const double t5543 = 2.0*t1019;
+              const double t5544 = 2.0*t1004;
+              const double t5545 = 2.0*t756;
+              const double t5547 = t513*xi;
+              const double t5548 = 2.0*t5547;
+              const double t5549 = 2.0*t514;
+              const double t5550 = 2.0*t997;
+              const double t5551 = t328*xi;
+              const double t5552 = 2.0*t5551;
+              const double t5554 = 2.0*t576;
+              const double t5555 = 2.0*t706;
+              const double t5556 = 2.0*t734;
+              const double t5557 = t464*vertices[1](1);
+              const double t5558 = 2.0*t5557;
+              const double t5559 = t3972*vertices[3](1);
+              const double t5560 = t5543+t5544+t5545+2.0*t384-t5548-t5549-t5550+t5552+2.0*t497-t5554-t5555-t5556+t3481+t3837-t4517+t5558-t1407+t2292+t5559;
+              const double t5561 = t5232*vertices[4](1);
+              const double t5562 = t5232*vertices[0](1);
+              const double t5563 = t395*t614;
+              const double t5564 = 2.0*t5563;
+              const double t5565 = t395*t499;
+              const double t5566 = 2.0*t5565;
+              const double t5567 = t705*t30;
+              const double t5568 = 2.0*t5567;
+              const double t5569 = t705*t8;
+              const double t5570 = 2.0*t5569;
+              const double t5571 = t480*t614;
+              const double t5572 = 2.0*t5571;
+              const double t5573 = t480*t499;
+              const double t5574 = 2.0*t5573;
+              const double t5575 = 2.0*t328;
+              const double t5576 = -t4540-t5017+t4015+t2240+t3443-t1859+t1701+t2619-t1886+t5561-t5562+t2536-t1683+t5564-t5566+t5568-t5570-t5572+t5574-t5575;
+              const double t5580 = 2.0*t481;
+              const double t5582 = 2.0*t523*t1434;
+              const double t5583 = t523*t71;
+              const double t5584 = 2.0*t5583;
+              const double t5585 = t523*t15;
+              const double t5586 = 2.0*t5585;
+              const double t5587 = t523*t438;
+              const double t5588 = 2.0*t5587;
+              const double t5589 = t290*t15;
+              const double t5590 = 2.0*t5589;
+              const double t5591 = t705*t59;
+              const double t5592 = 2.0*t5591;
+              const double t5593 = t705*t51;
+              const double t5594 = 2.0*t5593;
+              const double t5595 = t417*t123;
+              const double t5596 = 2.0*t5595;
+              const double t5597 = t1075*t123;
+              const double t5598 = 2.0*t5597;
+              const double t5600 = 2.0*t852*t123;
+              const double t5602 = 2.0*t586*t123;
+              const double t5603 = t765*t123;
+              const double t5604 = 2.0*t5603;
+              const double t5605 = t595*t123;
+              const double t5606 = 2.0*t5605;
+              const double t5607 = t568*t123;
+              const double t5608 = 2.0*t5607;
+              const double t5609 = 2.0*t513+t5580-t360-t768+t5582-t5584+t5586-t5588-t5590+t3612-t5592+t5594-t5596-t5598+t5600+t5602+t5604-t5606+t5608;
+              const double t5610 = t429*t1434;
+              const double t5611 = t429*t15;
+              const double t5612 = t429*t438;
+              const double t5613 = t768*t123;
+              const double t5614 = t429*t71;
+              const double t5615 = t480*t59;
+              const double t5616 = t480*t51;
+              const double t5617 = t979*t5;
+              const double t5618 = t412*t1434;
+              const double t5619 = t412*t71;
+              const double t5620 = t412*t687;
+              const double t5621 = t480*t18;
+              const double t5622 = t908*t183;
+              const double t5623 = t1252*t183;
+              const double t5624 = t464*t30;
+              const double t5625 = t464*t8;
+              const double t5626 = t979*t71;
+              const double t5627 = -t5610-t5611+t5612-t5613+t5614+t5615-t5616-t5617+t5618-t5619-t5620+t586+t489-t5621-t5622+t5623-t5624+t5625+t5626;
+              const double t5629 = t979*t687;
+              const double t5630 = 2.0*t5629;
+              const double t5632 = 2.0*t480*t453;
+              const double t5633 = t395*t349;
+              const double t5634 = 2.0*t5633;
+              const double t5635 = t736*t5;
+              const double t5636 = 2.0*t5635;
+              const double t5637 = t395*t453;
+              const double t5638 = 2.0*t5637;
+              const double t5639 = 2.0*t469;
+              const double t5641 = 2.0*t464*t349;
+              const double t5643 = 2.0*t1774*t123;
+              const double t5644 = t1252*t123;
+              const double t5645 = 2.0*t5644;
+              const double t5646 = t464*t156;
+              const double t5647 = 2.0*t5646;
+              const double t5649 = 2.0*t395*t18;
+              const double t5651 = 2.0*t480*t140;
+              const double t5652 = t5630+t5632-t447+t334+t5634+t5636-t5638-t5639-t5641+t5643-t5645+t5647+t568-t635+t5649+t5651-t1783-t4093+t1365;
+              const double t5654 = 2.0*t395*t156;
+              const double t5656 = 2.0*t464*t147;
+              const double t5657 = t464*t324;
+              const double t5658 = 2.0*t5657;
+              const double t5659 = t513*t183;
+              const double t5660 = 2.0*t5659;
+              const double t5661 = t383*t183;
+              const double t5662 = 2.0*t5661;
+              const double t5663 = t390*t183;
+              const double t5664 = 2.0*t5663;
+              const double t5665 = t412*t5;
+              const double t5666 = 2.0*t5665;
+              const double t5668 = 2.0*t469*t183;
+              const double t5669 = t733*t183;
+              const double t5670 = 2.0*t5669;
+              const double t5671 = t765*t183;
+              const double t5672 = 2.0*t5671;
+              const double t5673 = t595*t183;
+              const double t5674 = 2.0*t5673;
+              const double t5675 = t464*t508;
+              const double t5676 = 2.0*t5675;
+              const double t5678 = 2.0*t979*t1434;
+              const double t5680 = 2.0*t755*t183;
+              const double t5681 = t395*t508;
+              const double t5682 = 2.0*t5681;
+              const double t5683 = t395*t324;
+              const double t5684 = 2.0*t5683;
+              const double t5686 = -t5654-t5656-t383+t441-t5658+t5660-t5662+t5664+t5666-t5668+t5670-t5672+t5674+t5676-t5678-t5680-t5682+t5684+t733-2.0*t417;
+              const double t5691 = -t5505+t1318+t569+t980-t643+t843+t868-t822+t970-t655-t1734;
+              const double t5692 = t5529-t1847+t5532+t1244-t769-t751-t629+t683+t853-t5540-t1019;
+              const double t5694 = -t1004-t756-t384+t5548+t514+t997-t5552-t497+t576+t706+t734;
+              const double t5695 = t5405*vertices[4](1);
+              const double t5696 = t5405*vertices[5](1);
+              const double t5697 = t1785*vertices[5](1);
+              const double t5698 = t1785*vertices[4](1);
+              const double t5699 = t1785*vertices[1](1);
+              const double t5700 = t1785*vertices[0](1);
+              const double t5701 = t5386*vertices[5](1);
+              const double t5702 = t5386*vertices[4](1);
+              const double t5703 = t1990*vertices[2](1);
+              const double t5704 = t1990*vertices[1](1);
+              const double t5705 = t1990*vertices[0](1);
+              const double t5706 = t5695-t5696-t5697+t5698+t5699-t5700+t5701-t5702+t5703-t5704+t5705;
+              const double t5709 = t1976*vertices[3](1);
+              const double t5710 = t1976*vertices[2](1);
+              const double t5711 = t1976*vertices[1](1);
+              const double t5712 = t1976*vertices[0](1);
+              const double t5713 = -t5563+t5565+t5709-t5710-t5567+t5569+t5571-t5573+t5711-t5712+t328;
+              const double t5714 = t5386*vertices[3](1);
+              const double t5715 = t5386*vertices[2](1);
+              const double t5716 = t5405*vertices[3](1);
+              const double t5717 = t5405*vertices[2](1);
+              const double t5718 = t3031*vertices[5](1);
+              const double t5719 = t3031*vertices[4](1);
+              const double t5720 = t3031*vertices[1](1);
+              const double t5721 = t3031*vertices[0](1);
+              const double t5722 = -t513+t5714-t5715-t5716+t5717+t5718-t481-t5719-t5720+t5721-t5582;
+              const double t5724 = t5583-t5585+t5588+t5591-t5593+t5596+t5597-t5600-t5602-t5603+t5606;
+              const double t5725 = 2.0*t5610;
+              const double t5726 = 2.0*t5612;
+              const double t5727 = t1990*vertices[3](1);
+              const double t5728 = 2.0*t5618;
+              const double t5729 = -t5607+t5725+t5611-t5726+t5613-t5614-t5727-t5615+t5616+t5617-t5728;
+              const double t5733 = 2.0*t5620;
+              const double t5734 = t5619+t5733-t586-t489+t5624-t5625-t5626-t5630+t469+t5657-t5660;
+              const double t5738 = t5661-t5663-t5665+t5668-t5669+t5671-t5674-t5675+t5386*t147-t5386*t8+t5405*t8;
+              const double t5751 = t5386*t30-t5405*t30+t5405*t33-t5405*t147-t429*t414+t429*t550-t429*t528+t429*t520-t5375*t499-t1990*t51-t1990*t614;
+              const double t5763 = t1990*t453-t1990*t18+t1990*t499+t5375*t614-t5375*t453+t5375*t18+t1990*t59+t1990*t140-t1990*t138+t1976*t614-t1976*t453;
+              const double t5777 = t1976*t18+t1976*t138-t1976*t59-t1976*t140+t1976*t51-t5386*t33+t5386*t51+t5386*t138-t5386*t59-t5386*t140+t5405*t140;
+              const double t5788 = -t5405*t51+t5678+t3031*t324-t3031*t156-t5375*t508-t3031*t33+t3031*t147-t3031*t8-t3031*t508+t3031*t349+t3031*t30;
+              const double t5801 = t1785*t156+t1785*t8+t1785*t508-t1785*t349-t1785*t324+t1785*t33-t1785*t147-t1976*t499-t1785*t30-t412*t550-t412*t485;
+              const double t5809 = t412*t1162+t412*t414+t5375*t349+t5375*t324-t5375*t156+t5680+t5681-t5683+t417-t5405*t138+t5405*t59;
+              const double t5814 = (t5691+t5692+t5694+t5706+t5713+t5722+t5724+t5729+t5734+t5738+t5751+t5763+t5777+t5788+t5801+t5809)*t3605;
+              const double t5817 = 2.0*t102;
+              const double t5818 = 2.0*t139;
+              const double t5819 = 2.0*t155;
+              const double t5820 = t52-t54-t56-t61+t76+t5817-t108-t112+t118+t122+t137+t5818-t142-t146+t153-t5819;
+              const double t5821 = 2.0*t159;
+              const double t5823 = t2329*vertices[2](2);
+              const double t5825 = t778*vertices[0](2);
+              const double t5827 = t778*vertices[4](2);
+              const double t5828 = t157-t5821+t3928-t3849+t3832+t3843+t2740-t2758-t3829-t3847-t377*vertices[2](2)-t5823+t140*vertices[1](2)+t5825+t778*vertices[5](2)-t5827;
+              const double t5830 = vertices[2](1)*t340;
+              const double t5831 = t5830*vertices[4](2);
+              const double t5835 = t5830*vertices[0](2);
+              const double t5839 = vertices[2](1)*vertices[1](2);
+              const double t5842 = t1529*vertices[2](2);
+              const double t5843 = t5831-t778*vertices[1](2)-t5830*vertices[5](2)+t2726+t2736-t4602-t2738+t4594-t2364-t2761-t226*eta-t5835+t5830*vertices[1](2)+vertices[2](1)*vertices[5](2)*eta-2.0*t5839*eta+t5842;
+              const double t5844 = t1529*vertices[6](2);
+              const double t5846 = t2329*vertices[6](2);
+              const double t5852 = -t5844+t824*vertices[2](2)+t5846-t156*vertices[2](2)-t824*vertices[6](2)+2.0*t48*eta+t377*vertices[6](2)+t2775+t5839-t48+t119-t114+t91-t274-t88+t154;
+              const double t5856 = -t16-t49-t52+t54+t56+t61+t62-t76-t89+t92-t5817;
+              const double t5857 = t108+t110+t112-t115-t118+t120+t125-t127-t132+t134-t153;
+              const double t5859 = 2.0*t190;
+              const double t5862 = t5819-t157+t169-t188+t5859+t193-2.0*t194-t195-t197+t199+2.0*t200;
+              const double t5864 = vertices[0](1)*vertices[1](2);
+              const double t5865 = eta*zeta;
+              const double t5866 = t5864*t5865;
+              const double t5867 = 2.0*t5866;
+              const double t5869 = t51*t255;
+              const double t5871 = t51*t252;
+              const double t5874 = -t3510+t203+t215-t1213*t196-t5867+t1213*t176-t5869+t1213*t255+t5871-t1213*t252-t1213*t3565;
+              const double t5878 = -t224+2.0*t225-t227+t231-t235-t240+t250-t3928+t3849-t3832-t3843;
+              const double t5879 = -t2740+t2758+t3829+t3847-t2726-t2736+t4602+t2738-t4594+t2364+t2761;
+              const double t5881 = t18*vertices[3](2);
+              const double t5882 = vertices[3](1)*vertices[2](2);
+              const double t5883 = t5882*zeta;
+              const double t5884 = vertices[1](1)*vertices[0](2);
+              const double t5885 = t5884*eta;
+              const double t5886 = 2.0*t5885;
+              const double t5887 = t377*vertices[4](2);
+              const double t5888 = t5864*eta;
+              const double t5889 = 2.0*t5888;
+              const double t5890 = t1529*vertices[1](2);
+              const double t5891 = -t5881-t2775+t5883-t5886-t4437+t3818-t5887-t4591+t5889-t5890-t3784;
+              const double t5892 = t1529*vertices[5](2);
+              const double t5893 = t2329*vertices[5](2);
+              const double t5894 = t2329*vertices[1](2);
+              const double t5895 = t5864*zeta;
+              const double t5896 = t824*vertices[0](2);
+              const double t5901 = t3681+t5892-t5893+t5894+t5895-t5896+t5884-t1529*t174-t1529*t975+t1529*t296+t1529*t179;
+              const double t5905 = t453*vertices[0](2);
+              const double t5906 = t824*vertices[4](2);
+              const double t5907 = t377*vertices[0](2);
+              const double t5908 = t340*vertices[7](2);
+              const double t5910 = t340*vertices[4](2);
+              const double t5916 = t3738-t5905+t3839+t5906+t5907+t18*t5908-t18*t5910+t377*t206+t2329*t975-t2329*t296-t2329*t179;
+              const double t5917 = t340*vertices[3](2);
+              const double t5929 = -t18*t5917-t824*t210-t824*t174-t824*t975+t824*t296+t824*t212-t824*t206+t824*t204-t778*t212+t2329*t174+t824*t179;
+              const double t5937 = t156*t210;
+              const double t5938 = t140*t212;
+              const double t5939 = t140*t210;
+              const double t5940 = t156*t212;
+              const double t5942 = t778*t210+t778*t206-t778*t204-t1529*t252-t1529*t3565+t1529*t255+t5937+t5938-t5939-t5940+t15*t393;
+              const double t5943 = t340*vertices[0](2);
+              const double t5952 = 2.0*t5882*t5865;
+              const double t5953 = t55*t5865;
+              const double t5954 = -t15*t5943+t1529*t279+t191*t424+t191*t5943-t191*t393+t1213*t279-t191*t5910-t261+t114-t5952-t5953;
+              const double t5957 = t143*t5865;
+              const double t5958 = t119*t5865;
+              const double t5959 = 2.0*t5958;
+              const double t5960 = t64*t5865;
+              const double t5961 = t98*t5865;
+              const double t5963 = t453*t165;
+              const double t5965 = 2.0*t453*t189;
+              const double t5966 = t88*t5865;
+              const double t5967 = 2.0*t5966;
+              const double t5970 = t453*t168;
+              const double t5971 = 2.0*t5970;
+              const double t5972 = t5957+t5959+t5960-t5961-t1213*t162+t5963+t5965+t5967-t377*t179+t377*t174-t5971;
+              const double t5973 = t453*t187;
+              const double t5975 = t18*t189;
+              const double t5976 = 2.0*t5975;
+              const double t5978 = 2.0*t18*t168;
+              const double t5979 = t18*t187;
+              const double t5980 = t18*t165;
+              const double t5986 = -t5973-t377*t204-t5976+t5978+t5979-t5980+t18*t5943+t377*t210+t377*t975-t377*t296-t377*t212;
+              const double t5997 = -t91-t5864+t15*t5910-t15*t424+t438*t424-t2363*t279+t2363*t3565-t2363*t255+t2363*t252+t2329*t252+t438*t5943;
+              const double t6000 = t324*t255;
+              const double t6004 = t324*t252;
+              const double t6006 = -t438*t393-t438*t5910+t6000+t2329*t3565-t2329*t279-t2329*t255-t6004+t1213*t198+t88-t154-t3803;
+              const double t6011 = (t5856+t5857+t5862+t5874+t5878+t5879+t5891+t5901+t5916+t5929+t5942+t5954+t5972+t5986+t5997+t6006)*t3605;
+              const double t6014 = 2.0*t3793;
+              const double t6015 = 2.0*t5234;
+              const double t6016 = 2.0*t4043;
+              const double t6017 = t3964-t6014-t4572-t5233+t6015+t5236+t6016-t5246+t4134+t1902+t1888-t1935-t3947-t3937-t4027-t2782;
+              const double t6018 = vertices[2](0)*t340;
+              const double t6019 = t6018*vertices[0](2);
+              const double t6020 = t3940+t2830-t4198+t3942+t2785-t2777-t4169+t4172+t495+t5264-t4021-t2972+t2713+t4196-t5266-t6019;
+              const double t6022 = 2.0*t4135;
+              const double t6024 = t720*vertices[4](2);
+              const double t6026 = t720*vertices[0](2);
+              const double t6029 = t730*vertices[6](2);
+              const double t6030 = t730*vertices[2](2);
+              const double t6031 = t432*vertices[6](2);
+              const double t6032 = t432*vertices[2](2);
+              const double t6036 = -t6022+t720*vertices[5](2)-t6024-t720*vertices[1](2)+t6026+t1379*vertices[6](2)-t1379*vertices[2](2)-t6029+t6030+t6031-t6032+t341*vertices[2](2)-t341*vertices[6](2)-t2677-t290*vertices[2](2)+t2679;
+              const double t6038 = t6018*vertices[4](2);
+              const double t6042 = t559*vertices[1](2);
+              const double t6043 = vertices[2](0)*vertices[5](2);
+              const double t6048 = -t6018*vertices[5](2)+t6038+t6018*vertices[1](2)+t5271+2.0*t5266*eta+t6042+t6043*eta+t3864-2.0*t495*eta-t5311*eta+t300-t454-t2763-t860+t1029-t330;
+              const double t6052 = -t465-t6016+t5246-t4134-t1902-t1888-t517+t562+t1935-t1164+t3947;
+              const double t6053 = t4477+t1030+t3937+t4027+t2782-t3940-t2830+t4198-t3942-t2785+t2777;
+              const double t6057 = t4169-t4172-t5264+t4021+t2972-t2713-t4196-t5267+t6022+t836*t279-t836*t162;
+              const double t6061 = t292*t5865;
+              const double t6062 = 2.0*t6061;
+              const double t6063 = t404*t5865;
+              const double t6064 = 2.0*t6063;
+              const double t6065 = t622*t5865;
+              const double t6066 = t1300*t5865;
+              const double t6068 = t330*t5865;
+              const double t6069 = 2.0*t6068;
+              const double t6070 = t836*t176+t836*t198-t836*t196-t6062-t6064-t6065+t6066-t836*t3565+t6069+t2677-t2679;
+              const double t6077 = t366*t255;
+              const double t6079 = t366*t252;
+              const double t6081 = vertices[3](0)*xi;
+              const double t6085 = t432*t3565-t432*t279+t395*t5943-t395*t393+t6077-t432*t255-t6079+t432*t252-t6081*t5910+t6081*t424+t1709*t252;
+              const double t6090 = vertices[1](0)*vertices[0](2);
+              const double t6095 = t290*t212;
+              const double t6096 = t290*t210;
+              const double t6097 = -t1709*t279+t6081*t5943-t6081*t393+t1709*t3565+t6090+t464*t393+t464*t5910-t464*t424-t1709*t255-t6095+t6096;
+              const double t6099 = t559*t212;
+              const double t6100 = t559*t210;
+              const double t6106 = t1029*t5865;
+              const double t6107 = 2.0*t6106;
+              const double t6108 = t352*t5865;
+              const double t6109 = t461*t5865;
+              const double t6110 = t6099-t6100+t730*t255-t730*t252-t730*t3565+t730*t279-t464*t5943+t6107+t6108-t6109+t1178;
+              const double t6120 = -t5271+t341*t204-t720*t212+t720*t210+t720*t206+t341*t296+t341*t212-t341*t210-t341*t206-t292-t736*t5917;
+              const double t6133 = t736*t187;
+              const double t6134 = t736*t165;
+              const double t6135 = -t736*t5910+t736*t5908-t432*t179+t432*t174+t432*t975-t432*t296+t341*t179-t341*t174-t341*t975+t6133-t6134;
+              const double t6145 = t736*t189;
+              const double t6146 = 2.0*t6145;
+              const double t6147 = t736*t5943-t5274-t1379*t179+t1379*t174+t1379*t975-t1379*t296-t1379*t212+t1379*t210+t1379*t206-t1379*t204-t6146;
+              const double t6150 = 2.0*t736*t168;
+              const double t6151 = t792*t187;
+              const double t6152 = t792*t165;
+              const double t6157 = 2.0*t792*t189;
+              const double t6158 = t792*t168;
+              const double t6159 = 2.0*t6158;
+              const double t6162 = t412*t255;
+              const double t6163 = t6150-t6151+t6152-t730*t174-t730*t975+t730*t296+t6157-t6159-t395*t5910+t395*t424-t6162;
+              const double t6165 = t412*t252;
+              const double t6169 = t836*t255+t6165-t836*t252+t730*t179-t3864-t720*t204+t5279+t405+t5290+t5291+t5293;
+              const double t6172 = 2.0*t5299;
+              const double t6173 = 2.0*t5307;
+              const double t6174 = t730*vertices[1](2);
+              const double t6175 = -t6172+t3935+t5304-t6173-t300+t5308-t5315-t6174+t454-t5322+t5323;
+              const double t6176 = 2.0*t5324;
+              const double t6177 = t736*vertices[3](2);
+              const double t6178 = 2.0*t5332;
+              const double t6179 = t432*vertices[5](2);
+              const double t6180 = t792*vertices[0](2);
+              const double t6181 = t6176+t5325-t5486-t6177-t5330+t6178+t4676-t6179-t6180-t5341+t2755;
+              const double t6183 = t292*eta;
+              const double t6184 = 2.0*t6183;
+              const double t6185 = t432*vertices[1](2);
+              const double t6186 = t730*vertices[5](2);
+              const double t6187 = t1379*vertices[0](2);
+              const double t6188 = t1379*vertices[4](2);
+              const double t6189 = t341*vertices[0](2);
+              const double t6190 = t6184-t3917+t4546-t3969+t6185-t3961+t6186-t4155+t6187-t6188-t6189;
+              const double t6191 = t341*vertices[4](2);
+              const double t6192 = t6090*eta;
+              const double t6193 = 2.0*t6192;
+              const double t6194 = t3952*eta;
+              const double t6195 = t6191-t6193+t6194+t2763-t5349+t5351-t5357+t5364-t5365-t5368+t330;
+              const double t6200 = (t6052+t6053+t6057+t6070+t6085+t6097+t6110+t6120+t6135+t6147+t6163+t6169+t6175+t6181+t6190+t6195)*t3605;
+              const double t6203 = 2.0*t4517;
+              const double t6204 = 2.0*t2292;
+              const double t6205 = 2.0*t1701;
+              const double t6206 = -t980-t843+t4306+t1734+t1847-t5533-t1258+t5544+t3481+t3837-t6203-t1407+t6204-t1859+t6205+t5561;
+              const double t6207 = 2.0*t5562;
+              const double t6208 = -t6207-t328-t360-t768+t586+t334-t1783+t1365-t3764-t958+t1774-t3903+t4693+t1432-t1007+t3623;
+              const double t6210 = t432*vertices[6](1);
+              const double t6211 = t432*vertices[2](1);
+              const double t6216 = t6018*vertices[0](1);
+              const double t6217 = vertices[2](0)*vertices[5](1);
+              const double t6223 = -t4971-t1012+t1010-t6210+t6211+t1379*vertices[2](1)-t341*vertices[2](1)+t341*vertices[6](1)+t295-t1379*vertices[6](1)+t6216-t6217*eta+2.0*t958*eta+t1418-2.0*t2990+t6018*vertices[5](1);
+              const double t6224 = t6018*vertices[4](1);
+              const double t6227 = t720*vertices[4](1);
+              const double t6229 = t720*vertices[0](1);
+              const double t6231 = t730*vertices[6](1);
+              const double t6232 = t730*vertices[2](1);
+              const double t6233 = -t6224-t6018*vertices[1](1)-t720*vertices[5](1)+t6227+t720*vertices[1](1)-t6229-t559*vertices[1](1)+t6231-t6232-t1710+t3762+t3359+t5033-t1726-t5049+t3331;
+              const double t6237 = t334*t5865;
+              const double t6238 = 2.0*t6237;
+              const double t6240 = 2.0*t589*t5865;
+              const double t6241 = t383*t5865;
+              const double t6242 = t390*t5865;
+              const double t6244 = t980+t843+t5512-t822-t1734-t1847-t6238+t6240+t6241-t6242-t395*t1529;
+              const double t6247 = t395*t377+t395*t2329+t5531+t5533-t769+t1258-t5544+t997-t5551+t576-t3481;
+              const double t6249 = -t3837+t6203-t5557+t1407-t6204+t328+t360+t5589+t5592-t5593+t5595;
+              const double t6250 = 2.0*t5613;
+              const double t6251 = 2.0*t5626;
+              const double t6252 = -t5602-t5603+t5605-t5607+t6250-t5615+t5617-t5618+t5619-t586-t6251;
+              const double t6255 = -t5629-t334-t5633+t5641-t5643+t5644-t5646+t5657-t5676+t5678+t5681;
+              const double t6257 = t736*t324;
+              const double t6258 = t736*t51;
+              const double t6263 = t736*t508;
+              const double t6264 = 2.0*t6263;
+              const double t6266 = 2.0*t736*t59;
+              const double t6268 = t3764+t736*t2329-t6257+t6258-t736*t1529+t736*t2363-t1379*t499+t1379*t8+t6264-t6266-t1379*t30;
+              const double t6281 = t720*t8-t1379*t191+t1379*t600+t1379*t614+t341*t499+t341*t30-t341*t8+t720*t614-t720*t499-t720*t30-t341*t15;
+              const double t6292 = t792*t324;
+              const double t6293 = t341*t438+t341*t191-t341*t600-t341*t614-t1379*t438+t432*t15-t432*t438-t432*t191-t736*t1213+t432*t600+t6292;
+              const double t6297 = t792*t51;
+              const double t6301 = 2.0*t309*t5865;
+              const double t6302 = t768*t5865;
+              const double t6303 = 2.0*t6302;
+              const double t6304 = t733*t5865;
+              const double t6305 = t765*t5865;
+              const double t6308 = -t6297+t1379*t15+t309-t337+t836*t5+t6301-t6303-t6304+t6305+t836*t1434-t836*t71;
+              const double t6310 = t559*t499;
+              const double t6319 = t290*t614;
+              const double t6320 = -t836*t687+t6310-t730*t453-t836*t147+t464*t1529-t464*t377-t464*t2329+t464*t824+t1709*t453-t1709*t18+t6319;
+              const double t6322 = t290*t499;
+              const double t6323 = t559*t614;
+              const double t6331 = t412*t18;
+              const double t6333 = -t6322-t6323-t6081*t1529+t6081*t377+t6081*t2329+t730*t18+t730*t33-t730*t147-t836*t453-t6331+t836*t18;
+              const double t6337 = t366*t18;
+              const double t6343 = t412*t453;
+              const double t6344 = t366*t453;
+              const double t6345 = t836*t33-t1709*t33+t1709*t147+t6337-t432*t18-t432*t33+t432*t147-t6081*t824-t395*t824+t6343-t6344;
+              const double t6349 = 2.0*t2366;
+              const double t6350 = t341*vertices[0](1);
+              const double t6351 = t341*vertices[4](1);
+              const double t6352 = t432*t453+t3114+t2584-t1403+t1539-t2273-t310-t6349+t2527+t6350-t6351;
+              const double t6353 = t792*t59;
+              const double t6354 = 2.0*t6353;
+              const double t6358 = 2.0*t792*t508;
+              const double t6361 = t432*vertices[1](1);
+              const double t6362 = t432*vertices[5](1);
+              const double t6363 = t6354+t730*t191-t730*t600-t6358-t730*t15+t730*t438-t590-t6361+t2170+t6362-t1447;
+              const double t6365 = 2.0*t3002;
+              const double t6366 = t730*vertices[1](1);
+              const double t6367 = t730*vertices[5](1);
+              const double t6368 = t6365+t6366+t1815-t400-t6367+t3903-t4693-t1432+t1007-t3623+t4971;
+              const double t6369 = t1379*vertices[0](1);
+              const double t6370 = t1379*vertices[4](1);
+              const double t6371 = t1012-t1010+t1710-t3762-t3359-t5033+t1726+t5049-t3331-t6369+t6370;
+              const double t6376 = (t6244+t6247+t6249+t6252+t6255+t6268+t6281+t6293+t6308+t6320+t6333+t6345+t6352+t6363+t6368+t6371)*t3605;
+              const double t6379 = 2.0*t2;
+              const double t6380 = 2.0*t21;
+              const double t6381 = 2.0*t34;
+              const double t6382 = -t6379+t4+t9-t19+t6380-t27-t29-t31-t6381+t36-t67+t86-t99+t104-t145+t149;
+              const double t6383 = 2.0*t150;
+              const double t6384 = t6383-t10+t25-t64+t273-t20+t278+t1-t3725-t1116+t1119-t931+t4830-t4589+t1390+t1486;
+              const double t6387 = vertices[5](1)*vertices[1](2);
+              const double t6391 = -t4807+t783-t798-t3816+t3759+t3723+t4811-t3702+t3721+t679*vertices[6](2)-t1492-t6387+t22-t147*vertices[1](2)+t3656*vertices[1](2)-t3656*vertices[2](2);
+              const double t6405 = t3665+t3719-t3711*vertices[1](2)+t3711*vertices[2](2)-t3712-t3657-vertices[5](1)*vertices[2](2)*zeta+2.0*t6387*zeta+t443*vertices[5](2)-t443*vertices[6](2)-2.0*t22*zeta+t226*zeta+t4423-t4419+t18*vertices[5](2)-t679*vertices[5](2);
+              const double t6411 = t6379-t4-t6-t782*t975-t9-t11+t782*t196+t19-t6380+t23+t27;
+              const double t6412 = t443*vertices[3](2);
+              const double t6416 = t29+t31+t6412-t36+t38+t57-t65+t67-t679*t189+t782*t296+t679*t975;
+              const double t6422 = t350*vertices[4](2);
+              const double t6426 = -t679*t196-t72+t74-t679*t165-t86+t679*t187-t104+t679*t168-t349*t6422+t679*t198-t679*t296;
+              const double t6427 = t350*vertices[3](2);
+              const double t6429 = t350*vertices[0](2);
+              const double t6431 = t350*vertices[7](2);
+              const double t6435 = 2.0*t177;
+              const double t6437 = -t349*t6427+t349*t6429+t349*t6431+t164+t443*t296-t443*t975-t175-t6435+t181+t443*t196-t182;
+              const double t6445 = t8*t230;
+              const double t6446 = t100*t5865;
+              const double t6447 = vertices[4](1)*vertices[5](2);
+              const double t6448 = t6447*t5865;
+              const double t6451 = -t443*t198-t185+t186-t930*t176+t930*t162-t930*t222+t930*t230-t6445-t6446+2.0*t6448-t893*t296;
+              const double t6461 = t893*t975-t893*t196-t5*t6427+t5*t739-t207-t5*t479-t208+t5*t6429+t930*t3531+2.0*t209-t930*t233;
+              const double t6470 = t191*t6427+t213-2.0*t214+t216-t217-t191*t739+2.0*t218-t3514+t191*t479-t930*t174+t930*t179;
+              const double t6477 = t5867+t5869+t687*t6427-t191*t6429-t782*t3531+t782*t233+t244+t246-t249-t1485*t3531+t1485*t233;
+              const double t6488 = t140*t206;
+              const double t6490 = -t1485*t230+t1485*t222-t687*t6429-t687*t739+t687*t479-t256+t782*t222-t258-t782*t230+t6488+t140*t6431;
+              const double t6491 = t156*vertices[4](2);
+              const double t6492 = t6447*eta;
+              const double t6493 = 2.0*t5895;
+              const double t6494 = t6491-t6492+t5885+t4437-t3818+t4591-t5888+t3784-t3681-t6493-t5884;
+              const double t6496 = 2.0*t5905;
+              const double t6497 = 2.0*t5940;
+              const double t6498 = 2.0*t5960;
+              const double t6499 = -t3738+t6496-t3839-t5937-t5938+t6497+t5953-t5958-t6498+t5961-t5963;
+              const double t6500 = 2.0*t5973;
+              const double t6501 = 2.0*t6000;
+              const double t6502 = -t5965-t5966+t5970+t6500+t10+t5975-t5979+t265-t25+t5864-t6501;
+              const double t6511 = t6004+t276+t20+t893*t198+t893*t230-t893*t222+t893*t3531-t893*t233-t140*t6422+t283-t1;
+              const double t6517 = 2.0*t156*t206;
+              const double t6518 = t156*t204;
+              const double t6522 = t156*t6427-t156*t6431+t140*t6429-t140*t6427-t6517+t6518-t156*t6429-t782*t198+t156*t6422+t3725+t1116;
+              const double t6524 = -t1119+t931-t4830+t4589-t1390-t1486+t4807-t783+t798+t3816-t3759;
+              const double t6525 = t679*vertices[3](2);
+              const double t6526 = t679*vertices[0](2);
+              const double t6527 = t443*vertices[0](2);
+              const double t6528 = t782*vertices[2](2);
+              const double t6529 = t782*vertices[1](2);
+              const double t6530 = t893*vertices[2](2);
+              const double t6531 = t893*vertices[1](2);
+              const double t6532 = -t3723-t4811+t3803+t1492-t6525+t6526-t6527+t6528-t6529-t6530+t6531;
+              const double t6537 = (t6411+t6416+t6426+t6437+t6451+t6461+t6470+t6477+t6490+t6494+t6499+t6502+t6511+t6522+t6524+t6532)*t3605;
+              const double t6540 = t3983-t717+t3289-t3006-t4397+t4501-t4493-t875+t870+t4395+t3298-t3987-t3867-t3293+t3945-t3922;
+              const double t6541 = 2.0*t3787;
+              const double t6551 = t4298-t1193+t3295+t6541-t4287-t674*vertices[6](2)-t727*vertices[5](2)+t736*vertices[5](2)-t4107+t4047+t727*vertices[6](2)-2.0*t5300*zeta+t5311*zeta-t4124+t3745*vertices[2](2)-t3745*vertices[1](2);
+              const double t6559 = 2.0*t3778;
+              const double t6560 = 2.0*t3989;
+              const double t6561 = t3992-t1550+2.0*t1193*zeta+t4116-t3740*vertices[2](2)+t3740*vertices[1](2)-t4113-t3972*vertices[1](2)+t674*vertices[5](2)+t4032-t4039+t5300+t3899-t6559-t352-t6560;
+              const double t6562 = 2.0*t3953;
+              const double t6563 = 2.0*t1203;
+              const double t6564 = 2.0*t1191;
+              const double t6565 = t4505+t6562+t888+t3914+t606-t4681-t3966+t1202-t437+t850-t848-t1182-t6563+t6564+t358-t3952;
+              const double t6569 = -t3983+t717-t3289+t3006+t4397-t4501+t4493+t875-t870-t4395-t3298;
+              const double t6570 = t290*vertices[4](2);
+              const double t6571 = t650*vertices[2](2);
+              const double t6572 = t449*vertices[1](2);
+              const double t6573 = t674*vertices[0](2);
+              const double t6574 = t674*vertices[3](2);
+              const double t6575 = t727*vertices[0](2);
+              const double t6576 = t3987+t3293-t3945+t3922-t3295+t6570-t6571-t6572-t6573+t6574+t6575;
+              const double t6578 = t727*vertices[3](2);
+              const double t6579 = t449*vertices[2](2);
+              const double t6580 = t650*vertices[1](2);
+              const double t6581 = vertices[4](0)*vertices[5](2);
+              const double t6582 = t6581*eta;
+              const double t6583 = -t6578+t6579+t6580-t947-t6582-t353+t6560-t4505-t4612-t6562+t3223;
+              const double t6592 = -t888-t3914-t650*t296+t650*t975-t650*t196+t650*t198-t674*t198+t674*t196-t620*t6427+t806+t449*t222;
+              const double t6606 = -t449*t230-t449*t3531+t449*t233-t674*t975+t727*t187+t727*t168-t727*t189-t727*t296+t727*t975-t727*t196+t727*t198;
+              const double t6618 = t620*t6431-t620*t6422+t620*t6429+t674*t296-t559*t6422-t559*t6427+t559*t6429-t290*t6431+t290*t6422+t290*t6427-t290*t6429;
+              const double t6620 = t290*t204;
+              const double t6622 = 2.0*t290*t206;
+              const double t6628 = vertices[4](0)*xi;
+              const double t6633 = t6620-t6622+t449*t296-t449*t975+t449*t196-t449*t198-t727*t165-t6628*t6429+t711*t222-t711*t230-t711*t3531;
+              const double t6639 = t559*t206;
+              const double t6641 = t429*t230;
+              const double t6645 = t711*t233-t650*t222+t650*t230+t650*t3531-t650*t233+t6639+t559*t6431-t6641+t603*t3531-t603*t233+t395*t6427;
+              const double t6659 = -t395*t739+t395*t479-t395*t6429-t480*t6427+t480*t739-t480*t479+t480*t6429+t6628*t6427-t6628*t739+t6628*t479+t4681;
+              const double t6660 = t2853*t5865;
+              const double t6661 = t6581*t5865;
+              const double t6662 = 2.0*t6661;
+              const double t6669 = -t6660+t6662-t603*t174+t603*t179-t603*t176+t603*t162-t603*t222+t603*t230+t6062+t6065-t6068;
+              const double t6671 = 2.0*t6077;
+              const double t6672 = 2.0*t6095;
+              const double t6673 = 2.0*t6108;
+              const double t6674 = -t6671+t6079-t6090+t647+t6672-t6096-t6099-t6106-t6673+t6109+t292;
+              const double t6675 = 2.0*t6151;
+              const double t6676 = -t6133-t5272+t6145+t6675-t6152-t6157+t6158+t6162+t3966-t5277+t5283;
+              const double t6679 = 2.0*t5306;
+              const double t6680 = 2.0*t5310;
+              const double t6681 = -t1202+t437+t5301-t3935+t5302-t5303+t5478-t6679+t5309-t6680+t5312;
+              const double t6682 = 2.0*t5313;
+              const double t6683 = t6682-t5314-t2145-t5321-t850+t848+t1182+t6563-t6564-t4676+t5333;
+              const double t6685 = 2.0*t5336;
+              const double t6686 = 2.0*t6180;
+              const double t6687 = 2.0*t2755;
+              const double t6688 = -t5491+t6685-t5337-t5340+t6686+t5342-t6687-t6183+t3917-t4546+t3969;
+              const double t6689 = 2.0*t5343;
+              const double t6690 = t3961+t4155+t6192-t6194+t6689-t5344+t5355-t5360+t5361-t358+t3952;
+              const double t6695 = (t6569+t6576+t6583+t6592+t6606+t6618+t6633+t6645+t6659+t6669+t6674+t6676+t6681+t6683+t6688+t6690)*t3605;
+              const double t6698 = 2.0*t3629;
+              const double t6699 = 2.0*t2648;
+              const double t6700 = 2.0*t4015;
+              const double t6701 = -t1318+t1794+t2593-t1307-t3076+t6698+t2662-t6699+t655+t5535+t629-t5537-t514-t4540-t5017+t6700;
+              const double t6702 = 2.0*t1683;
+              const double t6703 = t2536-t6702-t926+t489-t447-t469-t635+t555+t4958-t5039-t3625+t3627+t441+t651+t604-t4980;
+              const double t6710 = t4982-t1125-t712+t4978-t5042-t450-t2265+2.0*t909+t714+t3741+t3748-t3745*vertices[2](1)+t3745*vertices[1](1)-t3746-2.0*t1635*zeta+t4530;
+              const double t6711 = t3972*vertices[1](1);
+              const double t6718 = -t4526+t6711+t674*vertices[6](1)-t674*vertices[5](1)-t727*vertices[6](1)-t3740*vertices[1](1)+t3267-t3772+t3740*vertices[2](1)-t908+t1635+t727*vertices[5](1)-t1639+t4620-t4558+t733;
+              const double t6722 = -t5504+t1318-t643-t1794+t1307+t5518+t3076-t6698-t2662-t5522+t6699;
+              const double t6723 = -t655+t5528+t6237-t6241-t5535-t629+t5537+t514+t706+t734-t5563;
+              const double t6725 = -t5568+t5569+t5572-t5573-t481-t5582+t5584-t5585+t5587+t5610-t5614;
+              const double t6726 = 2.0*t5622;
+              const double t6727 = t926-t489+t5621+t6726-t5623+t5624-t5632+t447-t5635+t5637+t469;
+              const double t6730 = -t555-t4958+t5039+t3625-t3627-t441-t5659+t5661-t651+t5668-t5670;
+              const double t6731 = t5671-t5673-t604+t4980-t4982+t1125+t712-t4978+t5042+t450-t714;
+              const double t6733 = t650*vertices[2](1);
+              const double t6734 = t650*vertices[1](1);
+              const double t6735 = t449*vertices[1](1);
+              const double t6736 = t727*vertices[3](1);
+              const double t6737 = t727*vertices[0](1);
+              const double t6738 = t674*vertices[3](1);
+              const double t6739 = t449*vertices[2](1);
+              const double t6740 = t674*vertices[0](1);
+              const double t6741 = t6733-t6734+t6735+t6736-t6737-t6738-t6739-t3131+t6740+t1134+t6257;
+              const double t6742 = 2.0*t6292;
+              const double t6744 = 2.0*t6304;
+              const double t6745 = 2.0*t6319;
+              const double t6746 = -t6263-t6742+t6297-t309+t337-t650*t687-t6301+t6302+t6744-t6305-t6745;
+              const double t6757 = t6322+t6323-t559*t930+t559*t1485+t559*t782-t559*t893+t650*t600-t650*t191-t6337+t650*t5-t6343;
+              const double t6758 = 2.0*t6344;
+              const double t6759 = 2.0*t1539;
+              const double t6760 = 2.0*t310;
+              const double t6763 = t6758-t3114-t2584+t1403-t6759+t2273+t6760+t2366-t2527+t449*t191-t449*t5;
+              const double t6769 = t290*t8;
+              const double t6771 = 2.0*t290*t30;
+              const double t6775 = t290*t930-t290*t1485-t290*t782+t290*t893-t6769+t6771+t727*t600-t727*t191-t6353+t727*t5+t6358;
+              const double t6787 = -t727*t687-t449*t600+t674*t191-t674*t5+t674*t687+t449*t687+t727*t51-t727*t324-t727*t59+t727*t508-t620*t893;
+              const double t6793 = t1075*t5865;
+              const double t6795 = 2.0*t1133*t5865;
+              const double t6802 = -t674*t600+t620*t1485+t620*t782+t6793-t6795-t620*t930+t603*t349-t395*t782+t395*t679+t395*t893+t480*t782;
+              const double t6810 = t1447-t3002-t1815+t400-t480*t679+t480*t443-t480*t893-t6628*t782+t6628*t679-t6628*t443+t6628*t893;
+              const double t6814 = t429*t156;
+              const double t6823 = -t395*t443-t603*t138+t6814-t603*t156+t603*t71-t603*t1434+t603*t140+t603*t438-t603*t15-t449*t349+t449*t156;
+              const double t6830 = t559*t30;
+              const double t6835 = t449*t138+t711*t156+t711*t138-t711*t349-t449*t140-t711*t140-t6830+t650*t140-t650*t156-t650*t138+t650*t349;
+              const double t6840 = (t6722+t6723+t6725+t6727+t6730+t6731+t6741+t6746+t6757+t6763+t6775+t6787+t6802+t6810+t6823+t6835)*t3605;
+              const double t6843 = t35+t13+t16+t942-t578-t521+t526-t529+t540+t545-t547+t42-t342-t81+t85+t89;
+              const double t6844 = -t93-t96-t107-t110+t116-t120+t2304-t2295-t44-t2018+t937+t105-t114-t1509+t91+t1609;
+              const double t6846 = t414*vertices[7](2);
+              const double t6847 = t414*vertices[6](2);
+              const double t6848 = t550*vertices[7](2);
+              const double t6849 = t550*vertices[6](2);
+              const double t6850 = t1162*vertices[6](2);
+              const double t6851 = 2.0*t1064;
+              const double t6852 = t1162*vertices[7](2);
+              const double t6853 = t485*vertices[7](2);
+              const double t6854 = -t83-t486+t653+t6846-t6847-t6848+t6849+t2480-t371-t6850+t506-t6851+t421+t6852-t1694-t6853;
+              const double t6855 = t485*vertices[6](2);
+              const double t6857 = t616*vertices[5](2);
+              const double t6858 = t616*vertices[4](2);
+              const double t6859 = t616*vertices[1](2);
+              const double t6860 = t616*vertices[0](2);
+              const double t6862 = 2.0*t343;
+              const double t6863 = t597*vertices[5](2);
+              const double t6864 = t597*vertices[4](2);
+              const double t6865 = t597*vertices[1](2);
+              const double t6866 = t597*vertices[0](2);
+              const double t6867 = t6855+t435-2.0*t387-t459+t6857-t6858-t6859+t6860+2.0*t961-t838+t6862-t6863+t6864+t6865-t6866+t386;
+              const double t6874 = t3607+2.0*t293+t299-t313-t316+t3611+2.0*t322-t327+t329+t3618-2.0*t332;
+              const double t6876 = 2.0*t335-t338-t339-t348-t357+t3650+t359+t3651-t370-t403+t408-t411;
+              const double t6878 = 2.0*t418;
+              const double t6879 = -t6878-t440-t3671-t446+t3672-t457+t470+t475+t482+t491+t492-t494;
+              const double t6882 = -t496-t3691-2.0*t504-t519-t533+2.0*t534+t538+t544-t3707+t549-t566+t571;
+              const double t6887 = -t584-t587-t588-t593+t594-t599+t3735-t606*t600-2.0*t615-t618+t619;
+              const double t6889 = t631-t639+t640+t649+t660+t663+t666+t671-t673-t3768+t606*t597-t675;
+              const double t6891 = 2.0*t691;
+              const double t6892 = 2.0*t696;
+              const double t6896 = vertices[5](2)*t350;
+              const double t6898 = t676-t3769-t3770+t680+t682+t6891+t3776+t6892-2.0*t699-2.0*t230*t398+t6896*t1152+t724;
+              const double t6899 = t222*zeta;
+              const double t6901 = 2.0*t6899*t833;
+              const double t6902 = vertices[6](2)*t350;
+              const double t6904 = 2.0*t737;
+              const double t6908 = -t729-t6901-t6902*t638+t6904+t6902*t497-t740+t744-t6896*t643+t746-t3801-t750-t6896*t497;
+              const double t6914 = 2.0*t255*t843;
+              const double t6916 = 2.0*t771;
+              const double t6922 = t6896*t569+t6914-2.0*t760+t764-t6916-t437*t597+t279*t417+t279*t469-t279*t489-2.0*t775+t786;
+              const double t6924 = 2.0*t1539*t692;
+              const double t6927 = 2.0*t222*t655;
+              const double t6930 = t791+t6924+2.0*t793-t796+t797-t800+t801-t802-t3822+t6927-t6896*t833-t255*t852;
+              const double t6941 = t814+t816-t835+t6896*t706+2.0*t30*t353+t3846-2.0*t564*t1076+t6896*t469+t831*t687-t252*t984+t6902*t1444-t3851;
+              const double t6953 = -t865-t866+2.0*t6899*t972+t6902*t964-t6902*t967-t444*t1162-t6896*t964-t733*t204-t3711*t1027-2.0*t873+t444*t5-t6902*t469;
+              const double t6960 = 2.0*t6042*t1197;
+              const double t6964 = t444*t485+t878-t896+t897+t899+t6896*t967-2.0*t903+t6960-t913+2.0*t230*t1076+t252*t852;
+              const double t6979 = t831*t1162-t831*t485-2.0*t444*t687-t918-t3871-t3876+2.0*t3565*t643-2.0*t230*t524-t6896*t595-2.0*t6581*t499-t6896*t1444+2.0*t6581*t614;
+              const double t6993 = -t935-2.0*t3565*t569+2.0*t954+2.0*t959+t3882-t3885-2.0*t5300*t688+t6902*t513-t6043*t687+2.0*t622*t30-t982+2.0*t222*t524;
+              const double t6998 = 2.0*t996;
+              const double t7003 = -t3890+t255*t984+t6902*t489-t279*t513-t6902*t755+t6998-2.0*t998-t1000+t733*t198+t1006+t6902*t595-t6896*t489;
+              const double t7013 = t6896*t417+t6902*t833+t3896+t1022-t1024-t779*t6855+t779*t6853-t779*t6852-t1026+t1028+t1032;
+              const double t7014 = 2.0*t1034;
+              const double t7018 = t51*zeta;
+              const double t7023 = 2.0*t5077*t2874;
+              const double t7028 = t7014+2.0*t779*t1694-2.0*t1038-2.0*t7018*t2854+t1042+t1044+t930*t1301-t1056-t7023+2.0*t564*t398+2.0*t5077*t2907+t3912;
+              const double t7041 = -t3913-t429*t1509-t736*t6857+t736*t6858-t3656*t887+t3711*t467-2.0*t1067-t1252*t917-t779*t386-t469*t303-t733*t306+t779*t44;
+              const double t7046 = 2.0*t1079;
+              const double t7048 = 2.0*t1081;
+              const double t7050 = 2.0*t233*t1318;
+              const double t7052 = 2.0*t1102;
+              const double t7053 = 2.0*t1106;
+              const double t7054 = 2.0*t1070-2.0*t358*t600+t1252*t1523-t7046+t3656*t1202+t7048+t1085-t7050+2.0*t1096+t7052+t7053-t3932;
+              const double t7069 = 2.0*t230*t430+t3933+t5300*t687+t6581*t15+t6896*t755-t622*t8-2.0*t352*t30-t622*vertices[4](1)+t6896*t638-t701*t614-t736*t386;
+              const double t7073 = 2.0*t620*t36;
+              const double t7077 = 2.0*t1386*t421;
+              const double t7079 = 2.0*t620*t67;
+              const double t7082 = t736*t44+t489*t196-t7073-t1132-2.0*t222*t430+t1142-t7077+t7079-t3656*t1176-t1148+t1151+t3656*t1027;
+              const double t7087 = t337*t975;
+              const double t7088 = t337*t296;
+              const double t7096 = -t792*t44+t792*t386-t6902*t417-t7087+t7088+t1163-t1168-2.0*t140*t3303+t1173-2.0*t6899*t1046+t3656*t947+2.0*t812*t2854;
+              const double t7097 = 2.0*t1183;
+              const double t7099 = t309*t296;
+              const double t7104 = 2.0*t1205;
+              const double t7105 = -t3960+t7097-t3656*t789-t7099+t469*t306+t765*t198-t3656*t437+2.0*t1190+t1196-t1199-t1200+t7104;
+              const double t7115 = 3.0*t1218;
+              const double t7118 = -t733*t296+t733*t303+t441*vertices[7](2)-t3711*t1202-t3711*t444+t3711*t887-t1216+t7115+2.0*t156*t3303-t1222-t1224;
+              const double t7122 = 2.0*t6899*t967;
+              const double t7128 = t3711*t1176+t3711*t437+t3979+t7122+t1229-t3711*t947+t1234+2.0*t1235-t1238+t3711*t789-2.0*t156*t2854-t1241;
+              const double t7135 = -2.0*t1242+t1243+t1246-t6902*t1152-t3994+t1253-2.0*t1257-t1261-2.0*t1263+2.0*t1266-t1268-t1271;
+              const double t7140 = -t1272+t1275-t1277+t1279-t1280-t1281+t1282-t1283+2.0*t852*t669+t1284+t1294-2.0*t489*t296;
+              const double t7146 = t309*vertices[7](2);
+              const double t7151 = -t1296+t1302-t4006+t1075*t2251-2.0*t453*t702+t7146-t852*t490-2.0*t1314+t1315+t489*t975-t6902*t706;
+              const double t7157 = 2.0*t1332;
+              const double t7161 = -2.0*t852*t1255+2.0*t1325-t1326+t1327+t1075*t490+t437*t616-t7157+t1338+2.0*t1340-2.0*t1342-t1075*t493-t1346;
+              const double t7172 = 2.0*t222*t1318;
+              const double t7173 = -t1133*t162+t1133*t174-t6902*t569+t852*t212-t1359+2.0*t1361+2.0*t1362+t6902*t643+t1366-t6581*vertices[0](1)-t7172+t1374;
+              const double t7183 = t779*t6850-2.0*t1377-t1378-t4059-2.0*t1382+2.0*t736*t1694+t792*t6852-2.0*t792*t1694-t1400+t736*t6853+t1402-t1405;
+              const double t7191 = 2.0*t1410;
+              const double t7194 = 2.0*t1420;
+              const double t7195 = 2.0*t1421;
+              const double t7196 = -t792*t6853-t792*t6850+t7191+t1412-t1413-t1415-t4078+2.0*t366*t1694+t7194-t7195-t1425;
+              const double t7204 = t1427-2.0*t425*t1694+2.0*t1429+2.0*t1430+t1431-t425*t6850-2.0*t1435+t4081-2.0*t1437+t1438-t1441-t1443;
+              const double t7206 = 2.0*t1454;
+              const double t7210 = -t1445-t1449+t1451-t1453-t7206-t1456+t1458+2.0*t635*t345+t635*t304-t4087-t1461-t4095;
+              const double t7215 = -t1464+t3972*t415-t4097+t4098-t1469+t1471+t1477+t4104-t4105+t3740*t1050-2.0*t1483+t3745*t459;
+              const double t7221 = 2.0*t1491;
+              const double t7229 = t489*t307+t852*t493-t425*t6853+t7221+t4112-2.0*t1227*t702-t1485*t353+t1505-2.0*t852*t747-2.0*t290*t386-t4122;
+              const double t7232 = 2.0*t1508;
+              const double t7236 = t425*t6855+t425*t6852+t7232+2.0*t852*t531+t852*t2620+t1513+t1515-t1517+t4127-t1519+t1520-t1524;
+              const double t7240 = -t1526+t1528+2.0*t1532-t4130+t1535+2.0*t1536-t1538-t1541+t1542+t1553+t1554+t4143;
+              const double t7244 = 3.0*t1569;
+              const double t7245 = t358*t597+t765*t917-t765*t1523+t1561-t4152-t7244+t1575+t1580+t1581-t1582+t1584+t1585;
+              const double t7251 = 2.0*t1596;
+              const double t7255 = t4159-t4160+t1590+t4165-4.0*t1594-t4167-t779*t6857-t7251+2.0*t2239*t1255+2.0*t1598+t1600;
+              const double t7256 = 3.0*t1606;
+              const double t7260 = t4174-t4175+t7256+t779*t6858+2.0*t1608+t1610-t1611-2.0*t1613-t4180-t4181-t1622+t4187;
+              const double t7262 = t1252*t162;
+              const double t7271 = 2.0*t1386*t371;
+              const double t7272 = t7262-t1252*t198+t736*t6850-2.0*t733*t345-t1636-t736*t6855+2.0*t425*t961-t1643+t7271+t1647+t1650+t4200;
+              const double t7275 = t1655-t1656+t1659+t1661-t1663-t736*t6852-t1666-t1670-t1671+t1677+t1485*t462+t1678;
+              const double t7281 = t595*t176;
+              const double t7286 = -t1679+t3745*t11-2.0*t1686+t1688-t4212+t1690-t469*t975+t7281-2.0*t595*t198+t595*t196+t595*t1523;
+              const double t7288 = 2.0*t1705;
+              const double t7291 = -t1193*t597-t1699+t1700+t1704-t7288+t1707+t792*t6857-t1714-t792*t6858+t1723+t1724+t4223;
+              const double t7301 = t4224+2.0*t1736-t3711*t2717+t1737+t1741-t4234-2.0*t779*t961+2.0*t779*t387-t1754+t4241-t779*t6864+t779*t6863;
+              const double t7302 = 2.0*t1756;
+              const double t7306 = -t7302+t4242+t1766+t1768-2.0*t779*t435+t1769+t1770+t1771-2.0*t1775+t1776-t1777+t1778;
+              const double t7311 = vertices[5](0)*vertices[4](1);
+              const double t7317 = t7311*vertices[3](2)-t1793+t429*t2127+t1796+t1797-t1799-t429*t2507-t1800+t792*t6864+t1802-t792*t6863;
+              const double t7328 = 2.0*t560*t506;
+              const double t7329 = -2.0*t792*t387+2.0*t792*t435-2.0*t156*t380+4.0*t1808-t1811+t1812+2.0*t792*t961-t1813-t4286-t7328+t1819-t4291;
+              const double t7337 = -t1822-t3972*t2127-t1824-t1826-t1830-t595*t917-t358*t616+2.0*t469*t296+t923*vertices[4](2)-t1833-t1835+t4300;
+              const double t7342 = t1837-t1839-t3740*t11+2.0*t1840+t3972*t2507-t1842+t1843-t1846-t1849-t1851-t3972*t1609+t1856;
+              const double t7352 = 2.0*t1865;
+              const double t7353 = -t1857-2.0*t3612*t345+2.0*t3612*t297-t3745*t1050+t4302-t3972*t1450+2.0*t1863-t7352+t1867-t1871+t1872;
+              const double t7360 = 2.0*t560*t1064;
+              const double t7361 = t4308-t3972*t653+t3972*t486-t4309-2.0*t1878-t1485*t1301-2.0*t1881-t4310+t4313+t7360+t4315-t1890;
+              const double t7365 = 3.0*t1896;
+              const double t7368 = -t1891+t4317-t930*t623+t1045*t212-t1895+t7365+t1904+t4319-t1907+t1909-t864*t196-t864*t1523;
+              const double t7379 = t864*t917-t3740*t342-t7311*t176+2.0*t1911-2.0*t1912-t1914+2.0*t1917-t930*t462-2.0*t736*t961+t3656*t510-t1918+t1919;
+              const double t7384 = 2.0*t1925;
+              const double t7388 = -t1920+2.0*t1924-t7384+t930*t353+t4327+t1931-t1933+t3656*t2874-t3656*t3223+t1934-t4328;
+              const double t7393 = 2.0*t5077*t725;
+              const double t7397 = t864*t162;
+              const double t7401 = 2.0*t5077*t702-t1938+2.0*t1939-t7393-t4329-t4330+t441*t975-2.0*t441*t296-t7397+t425*t386+2.0*t864*t198+t1942;
+              const double t7412 = t3656*t2717-t4331-2.0*t1944+2.0*t1946-t3656*t467+t4333+t1947-t3972*t10+t3972*t105-t425*t44+t595*vertices[4](2)+2.0*t4334;
+              const double t7423 = -t4335+2.0*t812*t380+t147*t509-t3711*t510+t1955-t1956-t3711*t2874+t1958-t1959-2.0*t736*t435+t3711*t3223+2.0*t736*t387;
+              const double t7432 = t4345+t736*t6863-t1964-t736*t6864+t4346-t1970-t1975-t1978-t1980+2.0*t429*t13-t1986-2.0*t429*t38;
+              const double t7438 = 2.0*t429*t42+t4353-t1992+t1993-2.0*t429*t57-t1995-t1996+t1998+t2001+t2002+t2003-t3740*t42;
+              const double t7444 = -2.0*t2007-t2008+t3740*t38+t2010+t2013-t2016+2.0*t2017-t3740*t1293-t2020+t4374+t2026-t2028;
+              const double t7445 = 2.0*t2030;
+              const double t7446 = 3.0*t2036;
+              const double t7452 = 2.0*t559*t67;
+              const double t7453 = t2029-t7445+t2032+t2034-t7446-t4380+2.0*t2042+2.0*t559*t1380+t3740*t1922+t7452+t2045+t4383;
+              const double t7460 = 3.0*t2056;
+              const double t7463 = -t2054-t2055-t7460+t4385+t2064+t2065-2.0*t559*t1393+t2066-t2067+t2068-t2069;
+              const double t7467 = -t3745*t38+t3745*t42-t2077+t2079+t3972*t1440+t2083-t2084+t2085+t2086-t2087-t2088+t2090;
+              const double t7472 = -t2091-t2095-t2096+t2099-t2102-t2104-t2106+t3972*t1509+2.0*t429*t11+t2111-t2112+t2114;
+              const double t7473 = vertices[5](0)*vertices[6](1);
+              const double t7480 = t2119-t2120+t2123+t7473*t2620-2.0*t290*t2480-t429*t1440+t429*t1450-t2138+t429*t653+t4411-t4416+t4418;
+              const double t7485 = 2.0*t413*t421;
+              const double t7490 = 2.0*t559*t36;
+              const double t7492 = t2150-t429*t486-t7485+t3740*t343+t7311*t179+t429*t1609-t7490+2.0*t2162+t2172-t2173+t2176;
+              const double t7494 = 2.0*t2186;
+              const double t7495 = 2.0*t2190;
+              const double t7501 = t2177-2.0*t2179-t2181-t2183+t7494-t2189-t7495-t2192-2.0*t2194-t635*t307+2.0*t2196-2.0*t635*t297;
+              const double t7506 = -t2197-t2239*t493+t2198+t2202+t2203+t358*t191+t2204-t2205+t2208+t4459-2.0*t4464-t2211;
+              const double t7515 = t4468+2.0*t828*t2480-t2216-t2218+t1485*t623-4.0*t2219-t2225+t2227+t2229+2.0*t560*t1694+t3740*t106+4.0*t2233;
+              const double t7526 = t2242-t3745*t106+t2244-t2245-t4485-t4486-2.0*t7311*t747+t2254+t2256+2.0*t7311*t669-2.0*t2239*t531;
+              const double t7535 = t2257-t2258-t2259+t2239*t490+t7473*t493-t7473*t2251-2.0*t2268+t2270+2.0*t7311*t212+t4497-2.0*t3266*t297-t4499;
+              const double t7538 = 2.0*t2285;
+              const double t7547 = t2284-t3266*t307-t7538+2.0*t1635*t297-t1635*t304-t2297-t2299+t1635*t307-t2239*t212-t7311*t174+t2301-2.0*t1635*t345;
+              const double t7554 = 2.0*t843*t669;
+              const double t7560 = 2.0*t523*t57-2.0*t523*t65+t352*vertices[4](1)-t7554+2.0*t2307-2.0*t523*t13+t2317-t4516+t2239*t2251-t2239*t2620-t4519-t2323;
+              const double t7567 = t292*t191;
+              const double t7572 = -t711*t57+t711*t13+2.0*t290*t387-t2339-t2342-t7567-t635*t198+t635*t204+t1635*t198-t2352-t3972*t540;
+              const double t7582 = t3972*t529+t2353+t2354-t2358+2.0*t2359+t2361+2.0*t1562*t435-t429*t557-t3972*t551+t711*t371+t3745*t1293-t3745*t1922;
+              const double t7584 = 2.0*t2382;
+              const double t7596 = -t2374+t2377+t7584-t2383-2.0*t290*t1380+t2385+2.0*t2390-2.0*t3777*t11+2.0*t2239*t747-2.0*t2394+2.0*t290*t1393+t3745*t105;
+              const double t7600 = 2.0*t2403;
+              const double t7604 = -t3745*t343-t4562-t852*t2251-t2399-2.0*t2400+t7600-2.0*t2239*t669-2.0*t2406-t2410+t4576-t2412-t2413;
+              const double t7617 = -t568*t304+2.0*t3777*t96-t3745*t83+t3745*t78+t3745*t84+t2418-t3612*t304-t2421+t3612*t307+t4586+t2429;
+              const double t7630 = t2431+t711*t667+2.0*t3777*t106+2.0*t429*t65-t711*t81-t425*t6863-t2432+t425*t6864-t7473*t490-2.0*t366*t435+t2437+t568*t307;
+              const double t7640 = -t2439-t2441+t2443-t2446-t489*t304-t852*t210+2.0*t3612*t206+t3612*t198-t3612*t204+t447*t304-t2456-t447*t307;
+              const double t7644 = 2.0*t310*t1180;
+              const double t7648 = t2458-t2459-t2461+t2462+t2474+2.0*t568*t297-t4623+t7644-t2487-t323*t485-t323*t5-t429*t10;
+              const double t7658 = -t417*t196+t417*t204+t429*t105+t4628+t2497-t711*t368-t429*t415+t2501-t2503+t429*t419-t711*t421;
+              const double t7661 = 2.0*t2755*t321;
+              const double t7667 = t2504+t2505+t711*t65-t7661-t2508-t2510-t429*t529+t429*t551+t429*t540+t2513-t429*t578+t3972*t557;
+              const double t7670 = 2.0*t2755*t3173;
+              const double t7679 = t7670+t2523+t603*t81-t2526+t4638-2.0*t2529-2.0*t2530+t3972*t578+2.0*t2532-2.0*t429*t96+t2534-t603*t667;
+              const double t7686 = 2.0*t3481*t1255;
+              const double t7688 = -2.0*t429*t81+2.0*t429*t84-t3972*t419+t2541+t4645+t2547+t7686-t2549-t2551-t3740*t84-t2562-t2563;
+              const double t7702 = -t4653+t4654+t2573-2.0*t3777*t25-t3266*t198+t3740*t83-t3740*t78+t3972*t25+t429*t25-2.0*t425*t387+t603*t421;
+              const double t7706 = 2.0*t2589;
+              const double t7714 = -t603*t65-t3740*t72+t3745*t1001+t7706+t2590-t2591-t4663+2.0*t425*t435+2.0*t489*t297-t2601-2.0*t417*t297-4.0*t2615;
+              const double t7719 = 2.0*t453*t1888;
+              const double t7724 = t2618+2.0*t417*t2223+t4671-t2625-t7719+t2629+t2631-t489*t204-t429*t83-t3740*t25+t3740*t35+t2632;
+              const double t7726 = 2.0*t6711*t1945;
+              const double t7729 = 2.0*t453*t1935;
+              const double t7733 = 2.0*t413*t371;
+              const double t7734 = -t7726-2.0*t2635+t2637+t7729-2.0*t413*t2480+t2642-t2643-t2644+t7733-t2647+t2651+t2659;
+              const double t7745 = t417*t304-t417*t307-t2665-t2666+t425*t6857-t425*t6858-t4696-t2670+2.0*t323*t687-t362*t1162+t489*t303;
+              const double t7760 = -t476*t198-t3740*t1001-t603*t13+t3740*t96+t603*t57+2.0*t413*t838+2.0*t156*t379+t635*t296+t3740*t728-t635*t303+t635*t306+t603*t368;
+              const double t7769 = 2.0*t2692;
+              const double t7771 = 2.0*t560*t343;
+              const double t7773 = t4702+t2682-2.0*t429*t74-t2687+t429*t942+t4707+2.0*t290*t838-2.0*t560*t961-t7769-t7771+t4708+t3266*t304;
+              const double t7781 = 2.0*t2728;
+              const double t7782 = -t3740*t1064-t2710+t4724+2.0*t429*t72-2.0*t560*t435+t3740*t74-t4730-2.0*t2720-t4732+t4733+t2725-t7781;
+              const double t7793 = 2.0*t140*t848;
+              const double t7797 = 2.0*t140*t888;
+              const double t7801 = t2730-2.0*t812*t826+2.0*t140*t840-t7793+2.0*t324*t702+t2743+t7797-t2747+t513*t196+t2754+2.0*t3565*t497;
+              const double t7815 = -t6896*t513+t701*t499-t6581*t71+t352*t8-t606*t616+2.0*t437*t600-t437*t191+2.0*t230*t852-2.0*t230*t984+t4748+t2757+t3711*t806;
+              const double t7827 = -t3656*t542-t3656*t509+t3656*t788+t3711*t509-t2760+t3745*t1064+t4752-t603*t371-t2766-t3745*t74+t3740*t506+2.0*t560*t387;
+              const double t7829 = 2.0*t560*t459;
+              const double t7835 = 2.0*t2791;
+              const double t7839 = t2770+t7829-t4754+t4759-2.0*t828*t387-t489*t306-t4763-2.0*t290*t961+t7835-t4764-t3972*t942+2.0*t828*t961;
+              const double t7847 = t2805+t2807-t2808-t2809+t2810-t4770-t4772-2.0*t828*t838-t638*vertices[4](2)+2.0*t2813-t3745*t96;
+              const double t7848 = 2.0*t2816;
+              const double t7856 = 2.0*t2366*t297;
+              const double t7857 = 2.0*t2832;
+              const double t7858 = -t7848-t3745*t506+t3745*t72-t2822+t4777+t362*t485-2.0*t156*t1772+t2239*t210-t2828-t7856-t7857+t2838;
+              const double t7863 = t638*t176;
+              const double t7864 = t1820*t162;
+              const double t7870 = -t447*t303+t18*t379-t476*t917-t7863-t7864-t2842-t2843+t2844-2.0*t7311*t210+t7311*t162-t3745*t10+t3745*t342;
+              const double t7875 = t309*t975;
+              const double t7877 = t362*t1434;
+              const double t7878 = t3740*t10-t3740*t105+t1193*t600+t1193*t616+t2846-t2847+t2848+t2850+t7875-t362*t687+t7877-t2851;
+              const double t7887 = 2.0*t447*t296+t1820*t198+t447*t306+t323*t1162+t2852-t2859+t4792-t4796-t2868+t2870-t2873;
+              const double t7898 = t4797-t469*t196-t453*t379-t1635*t306-t1635*t296+t1635*t303-t2885+2.0*t18*t702+t4802+t923*t1523-t923*t917-t18*t1772;
+              const double t7902 = t923*t162;
+              const double t7907 = -t447*t975+t1820*t917+t7902-2.0*t923*t198+t923*t196-t2893+t4806-t2896+t2898+t2900+2.0*t2906-t4818;
+              const double t7914 = 2.0*t156*t826+t2912-t2914+t2915+t2916+t2917+t3745*t25-t3745*t35-t3972*t83-t3612*vertices[4](2)-t2920+t4822;
+              const double t7923 = 2.0*t2928;
+              const double t7927 = -t2922+2.0*t33*t947+t3656*t610+4.0*t2923-2.0*t156*t840-t7923-2.0*t4825-t2929-2.0*t33*t467-t2936-t4839;
+              const double t7929 = 2.0*t2948;
+              const double t7938 = t4841+2.0*t2946-t7929-t4844+2.0*t290*t44-t4846-2.0*t2957+2.0*t1045*t669-2.0*t1045*t747+t4852+t2962+t3711*t895;
+              const double t7947 = -t3711*t725-2.0*t1133*t669+2.0*t2969+t2974-t2975+t2976-t2977-t3656*t895-t2980-t3656*t806+t3656*t725-t4855;
+              const double t7949 = 2.0*t5077*t1176;
+              const double t7960 = t2982-t2983-t4857+t2987+t7949+t635*vertices[4](2)-t147*t1027+2.0*t33*t1202-2.0*t33*t437+2.0*t33*t1027-t1045*t210+t3711*t542;
+              const double t7968 = 2.0*t7018*t462;
+              const double t7976 = -t2993-2.0*t5077*t1206-t2997+t7968-2.0*t30*t623-t3711*t610-t4863+t383*t204-t908*t198-t147*t1202+t147*t437;
+              const double t7983 = t4869+t3024+2.0*t638*t198-t638*t196-t638*t1523+t638*t917+t476*t1523-t4875-t3037-t3039-t3043+t3051;
+              const double t7986 = 2.0*t3074;
+              const double t7987 = -t3053+t3058-t4880+2.0*t4881+t4883+t3065+t4886+t7986+t3078-t4892-t4894+t4896;
+              const double t7988 = 2.0*t3106;
+              const double t7995 = t4901-t7988-t1075*t2620+t792*t6855-2.0*t3113-2.0*t1562*t1694+t3128+t3133-t3139+t3142+t4912+2.0*t3150;
+              const double t7998 = 2.0*t3182;
+              const double t8003 = -t3157-t3160-t3164+t3175-t7998+t3184+t4917-t441*t306+t908*t306+t908*t296-t908*t303;
+              const double t8005 = t441*t303-t4925-t3200-t3206+t4928+t3210+t3213+t4932+t3221+t3238+t3240-t4943;
+              const double t8007 = 2.0*t3249;
+              const double t8011 = 2.0*t3272;
+              const double t8012 = -t8007-t4944-t4945-t3740*t459-2.0*t429*t106-t3261+t3262-t3263+t3265-t3269+t8011+t4963;
+              const double t8028 = 2.0*t1133*t747+2.0*t33*t510-t3711*t788-t1133*t179+t6217*t198-2.0*t383*t206-t383*t198-t3745*t728+t3656*t444+t453*t1772-t1820*t1523+t1133*t176;
+              const double t8037 = 2.0*t3352;
+              const double t8038 = -t447*vertices[7](2)-t5002+t5006+t5008-2.0*t447*t297-t437*vertices[7](1)+t3333-t5028+t3337-2.0*t3350+t8037;
+              const double t8044 = t923*vertices[0](2);
+              const double t8045 = t383*vertices[4](2)+t1133*vertices[0](2)-t733*vertices[4](2)-t3364-t5064-t3368+t5066+t3372-t7311*vertices[0](2)+t489*vertices[7](2)+t3375-t8044;
+              const double t8049 = t292*vertices[7](1);
+              const double t8051 = -t5071+t3388+t5079-t3391+t3393+t6581*vertices[3](1)-2.0*t3394-t3395-t8049+t3396+t444*vertices[4](1)-t5080;
+              const double t8055 = t337*vertices[7](2);
+              const double t8057 = 2.0*t3410-2.0*t3412-t3413-t3414-t3417+t3419-t1133*vertices[3](2)+t3423-t3424-t8055+t5087-2.0*t3425;
+              const double t8060 = 2.0*t3428;
+              const double t8061 = t864*vertices[0](2);
+              const double t8064 = t5091+t5096-t5098+t8060+t8061-t3430-t3431+t358*vertices[7](1)-t469*vertices[7](2)+t3435+t5101-t5102;
+              const double t8066 = t323*vertices[0](1);
+              const double t8069 = 2.0*t6192*t601;
+              const double t8070 = t3439+t5103+t3445-t323*vertices[4](1)-t5105+t8066-t3450-t864*vertices[4](2)-t3452-t8069+t3453-t3456;
+              const double t8072 = 2.0*t3466;
+              const double t8073 = 2.0*t3469;
+              const double t8075 = -t5108+t3458-t3461+t3462-t5111-t8072+t8073+t3472+2.0*t3473-t3474+t3476+t3477;
+              const double t8078 = -t5120-t5128-t5134+t5136+2.0*t5138-t5167-2.0*t5193+t5198-t3479-t5211-t3483-t3484;
+      s1 = t7658+t7151+t7734+t7069+t7667+t7342+t7196+t6879+t7204+t7679+t7082+t8057+t7444+t6887+t7688+t7096+t8064+t7960+t6882+t7229+t7105+t6889+t6874+t7236+t7702+t7604+t7240+t7353+t7839+t6898+t7118+t7453+t7245+t7128+t7714+t7361+t8051+t7140+t7135+t7432+t7858+t7368+t6908+t7724+t7438+t8078+t7463+t8070+t7272+t7161+t7878+t7379+t7976+t7983+t7745+t7560+t7987+t7173+t6922+t7887+t7291+t6979+t7388+t7898;
+              const double t8085 = s1+t7760+t7301+t7183+t7480+t7492+t7306+t7467+t7472+t6953+t7995+t6876+t7013+t6930+t7907+t7215+t7773+t7210+t7401+t7782+t7914+t7801+t7501+t6941+t7317+t7260+t8003+t7255+t7572+t7815+t7506+t7329+t8005+t7275+t7927+t8012+t7412+t6964+t7286+t8075+t7827+t7515+t7847+t6993+t7938+t7003+t7526+t7028+t7041+t7337+t7423+t8028+t7054+t7947+t7535+t7547+t8045+t7582+t7596+t8038+t7617+t7870+t7630+t7640+t7648;
+              const double t8088 = t5383-t5384+t5387-t5388-t5391+t5392+t5398-t5399-t3034+t3032-t5400+t5401+t1786-t2856+t5410-t5423;
+              const double t8089 = t5386*vertices[7](2);
+              const double t8091 = t5405*vertices[6](2);
+              const double t8092 = t5405*vertices[7](2);
+              const double t8093 = t5386*vertices[6](2);
+              const double t8094 = vertices[7](0)*t302;
+              const double t8095 = t8094*vertices[1](2);
+              const double t8097 = t465+t517+t5253-t623+t1176-t467-t8089-t5257-t1206+t1990*vertices[7](2)-t8091+t8092+t610+t8093+t8095-t8094*vertices[5](2);
+              const double t8101 = 2.0*t2874;
+              const double t8104 = t8094*vertices[0](2);
+              const double t8105 = 2.0*t445;
+              const double t8108 = t8094*vertices[4](2)-t2854+2.0*t2907+t5261-t8101+t462-t1990*vertices[6](2)-2.0*t380-t1030-t8104-t725+t8105+t702-t5375*vertices[4](2)+t5375*vertices[5](2)-t444;
+              const double t8109 = t5375*vertices[0](2);
+              const double t8110 = t5375*vertices[1](2);
+              const double t8113 = -t1098+t826+t8109-t8110-t1178-t1772+t379+t887-t1976*vertices[7](2)+t1976*vertices[6](2)+t1027+t300-t454-t509+t1160-t5493;
+              const double t8119 = -t569+t822-t970-t5532+t769+t5540+t384-t5548-t997+t5552+t497-t576+t5697-t5698-t5699+t5700;
+              const double t8120 = t5375*vertices[0](1);
+              const double t8121 = -t5703-t5709+t5710-t328+t513-t5714+t5715+t5716-t5717-t5718+t5719+t5720-t5721+t5727+t586-t8120;
+              const double t8127 = t8094*vertices[1](1);
+              const double t8128 = t8094*vertices[0](1);
+              const double t8131 = t852-t984-t595-t417+t638-t766-t1990*vertices[7](1)+t972+t1990*vertices[6](1)+t8094*vertices[5](1)-t8094*vertices[4](1)-t8127+t8128-t1046+2.0*t984*xi+t967;
+              const double t8132 = t638*xi;
+              const double t8133 = 2.0*t8132;
+              const double t8136 = t5375*vertices[1](1);
+              const double t8137 = t595*xi;
+              const double t8138 = 2.0*t8137;
+              const double t8139 = t5405*vertices[6](1);
+              const double t8142 = t5405*vertices[7](1);
+              const double t8143 = t5386*vertices[6](1);
+              const double t8144 = t5386*vertices[7](1);
+              const double t8147 = -t8133-t5375*vertices[5](1)+t5375*vertices[4](1)+t8136-t398+t396+t1076+t8138+t8139-2.0*t852*xi-t8142-t833-t8143+t8144-t1976*vertices[6](1)+t1976*vertices[7](1);
+              const double t8156 = t2+t35-t4-t9+t13+t17+t19-t21+t29-t34-2.0*t41+t42+t46+t50+t53-2.0*t54-t342-2.0*t56-t61;
+              const double t8157 = -t63-t70+t77-t81+t84+t90-t93-t96-t99+t5817-t106-t109-t111-t113+t116+t118-t121-t125+t127;
+              const double t8163 = -t130+t133-t135+t144-t145-t148+t149+t150-t152+2.0*t153-t5819+2.0*t157+t158+t160+t167-t170+2.0*t188-t5859-2.0*t192;
+              const double t8164 = -t193+t194+t195+t197-t199-t200+t201-t6445-t6446+t6448-t203-t215-t220+t221+t5866+t5869-t5871-t223+t224-t225;
+              const double t8167 = t227-t231+t234-t236+t238+t240+t242-t250+t6488+t6491-t6492+t5881-t5883+t5885+t4437-t3818+t4591-t5888+t3784;
+              const double t8170 = 2.0*t3738;
+              const double t8171 = 2.0*t3839;
+              const double t8172 = 2.0*t5937;
+              const double t8173 = 2.0*t5938;
+              const double t8174 = 2.0*t5939;
+              const double t8175 = 2.0*t5953;
+              const double t8176 = 2.0*t5957;
+              const double t8177 = 2.0*t5961;
+              const double t8178 = -2.0*t3681-t6493-2.0*t5884-t8170+t6496-t8171+t105-t8172-t8173+t8174+t6497+t262-t263+t5952+t8175-t8176-t5959-t6498+t8177;
+              const double t8180 = 2.0*t5963;
+              const double t8181 = 2.0*t5979;
+              const double t8182 = 2.0*t5980;
+              const double t8183 = 2.0*t5864;
+              const double t8184 = 2.0*t6004;
+              const double t8187 = -t8180-t5965-t5967+t5971+t6500+t5976-t5978-t8181+t8182+t269+t8183-t6501+t8184-t83-t64+t273+t55-2.0*t88+2.0*t154;
+              const double t8189 = t191*vertices[1](2);
+              const double t8191 = 2.0*t140*t204;
+              const double t8193 = 2.0*t51*t279;
+              const double t8194 = t226*xi;
+              const double t8195 = 2.0*t6518;
+              const double t8196 = 2.0*t3803;
+              const double t8197 = t20+t278-t1-t284+2.0*t285-t28+t8189-t8191+t8193-t8194-t6517+t8195+t8196-t371+t458+t506-t1064+t421-t459+t343;
+              const double t8204 = t395*vertices[1](2);
+              const double t8208 = 2.0*t559*t204;
+              const double t8209 = 2.0*t6570;
+              const double t8211 = 2.0*t412*t279;
+              const double t8212 = 2.0*t6582;
+              const double t8213 = t5223+t8204-t3867+t5224-t5226+t4298-2.0*t5227-t5229+t3787+2.0*t4018+t5231-t4287-t8208+t3899+t8209+t8211-t3778-t5239-t8212;
+              const double t8215 = -t352+t3989-t4505-t3953+t5243+t6016-t3914-t5246+2.0*t4134+t5247+t5250+t606-t5251+t5252+t510-t623+t1176-t467-t5257;
+              const double t8218 = 2.0*t6620;
+              const double t8219 = 2.0*t6639;
+              const double t8220 = 2.0*t6641;
+              const double t8221 = 2.0*t6660;
+              const double t8222 = -t5258+t610+t5261-t2874+t462-2.0*t3947-t5262-t5263-t725+t445-t444-t1098+t8218-t6622+t8219-t8220+t4681+t5264-t8221;
+              const double t8223 = t6661-t4021+t5267-t4135+t6061+t6063+t6065-t6066-t6068-t6077+t6079-t6090+t6095-t6096-t6099+t6100-t6106-t6108+t6109-t1178;
+              const double t8227 = 2.0*t292;
+              const double t8228 = 2.0*t6133;
+              const double t8229 = 2.0*t6134;
+              const double t8230 = 2.0*t6152;
+              const double t8231 = 2.0*t6162;
+              const double t8232 = 2.0*t6165;
+              const double t8234 = 2.0*t405;
+              const double t8235 = 2.0*t5271+t8227-t8228+t8229+t5275+t6146-t6150+t6675-t8230-t6157+t6159+t8231-t8232+2.0*t3864+t3966+t887-t5280+t5286-t8234;
+              const double t8236 = 2.0*t3935;
+              const double t8238 = t5311*xi;
+              const double t8246 = -t5290-t5292-t5294+t6172-t8236-2.0*t5304-t8238+t6173-t4680+t1027+t323+2.0*t300-2.0*t5308+2.0*t5315-2.0*t5316-2.0*t454-t509-2.0*t5319+2.0*t5322;
+              const double t8248 = 2.0*t6177;
+              const double t8251 = 2.0*t4676;
+              const double t8254 = 2.0*t3917;
+              const double t8255 = 2.0*t4546;
+              const double t8256 = -t5483-t6176-t5484+t1160+t5486+t8248+2.0*t3096+2.0*t5330+t5487-t6178-t8251-2.0*t5334-t1937+t6686+2.0*t5341-t6687-t6184+t8254-t8255;
+              const double t8257 = 2.0*t3969;
+              const double t8258 = 2.0*t3961;
+              const double t8259 = 2.0*t4155;
+              const double t8260 = 2.0*t6194;
+              const double t8264 = t8257+t8258+t8259+t6193-t8260-2.0*t2763+2.0*t5345-t5348+t5350-t5352+t622+t5358-t4060-t5364+t5366+t5368+t3798-t358-2.0*t330+t3952;
+              const double t8272 = -t923+t864-t569-t5508-t5510-t5513-t1794+t5514-2.0*t1653-t2482+t2593-t5516+t1307+t3076-t3629-t970-t2662+t2648+t5525;
+              const double t8273 = 2.0*t6241;
+              const double t8274 = 2.0*t6242;
+              const double t8276 = t5526+t5530+t6238-t6240-t8273+t8274-t5532-t5533+t5534-t5538+t5539-2.0*t1258+t5543+t5544+t384-t5547-t5550+t5552+t497;
+              const double t8282 = t1252*xi;
+              const double t8283 = t395*vertices[1](1);
+              const double t8284 = -t5554+2.0*t3481+2.0*t3837-t6203+t5558-2.0*t1407+t6204+t5559-t4540-t5017+t4015+2.0*t2240-t3443+t1886+t2536-t1683+t8282-t8283-t5575;
+              const double t8287 = 2.0*t559*t8;
+              const double t8289 = 2.0*t412*t147;
+              const double t8293 = t513-2.0*t360-t5590+t3612-t5592+t5594-t5596-t5598+t5600+t8287+t5602+t5604-t5606+t5608-t8289-t6250+2.0*t5615-2.0*t5616-2.0*t5617+t5728;
+              const double t8299 = -2.0*t5619-t5733+2.0*t586+t6251+t5630+t447+2.0*t334+t5634-t5641+t5643-t5645+t5647-t635+t5651-t5654-t383-t441-t5658+t5666;
+              const double t8300 = 2.0*t3131;
+              const double t8301 = 2.0*t1134;
+              const double t8302 = 2.0*t6257;
+              const double t8303 = 2.0*t6258;
+              const double t8304 = 2.0*t6297;
+              const double t8305 = 2.0*t309;
+              const double t8306 = 2.0*t337;
+              const double t8307 = t5676-t5678-t8300-t5682+t5684+t733+t8301+t8302-t8303-t6264+t6266-t6742+t8304-t595-t8305+t8306-t6301+t6303+t6744;
+              const double t8309 = 2.0*t6305;
+              const double t8310 = 2.0*t6310;
+              const double t8311 = 2.0*t6322;
+              const double t8312 = 2.0*t6323;
+              const double t8313 = 2.0*t6331;
+              const double t8314 = 2.0*t6337;
+              const double t8315 = 2.0*t6343;
+              const double t8316 = 2.0*t3114;
+              const double t8317 = 2.0*t2584;
+              const double t8318 = 2.0*t1403;
+              const double t8319 = 2.0*t2273;
+              const double t8320 = 2.0*t2527;
+              const double t8321 = 2.0*t6769;
+              const double t8322 = -t8309-t8310-t6745+t8311+t8312-t417+t8313-t8314-t8315+t6758-t8316-t8317+t8318-t6759+t8319+t6760+t6349-t8320-t8321;
+              const double t8331 = t6771-t6354+t6358+2.0*t590+t638+2.0*t6793-t6795-t766-2.0*t2170+2.0*t1447-t6365+t967-2.0*t1815-t8132+2.0*t400+t396+t8137+2.0*t6814-t833-2.0*t6830;
+              const double t8338 = vertices[5](1)*vertices[4](2);
+              const double t8341 = -t6379+t4+t9-t19+t6380-t29-t6412+t6381+t99+t145-t149-t6383+t8338-t6447+t3621-2.0*t8338*zeta;
+              const double t8352 = -t3711*vertices[7](2)+t3711*vertices[4](2)+t3656*vertices[7](2)+t3683-t3656*vertices[4](2)-t1485*vertices[5](2)+t1485*vertices[6](2)-t930*vertices[6](2)+t930*vertices[5](2)-t4421-t4361+2.0*t6447*zeta-t4437-t4591+t3681+t6493;
+              const double t8354 = t5884+t3738-t6496-t5864+t64-t273-t20-t278+t1-t3725+t4830-t4589-t4807-t3816+t3759+t3723;
+              const double t8355 = t4811+t3702-t3721-t3665-t3719+t3712+t3657-t4423+t4419+t6525-t6526+t6527-t6528+t6529+t6530-t6531;
+              const double t8361 = t3983-t4397+t4501-t4493+t4395-t3987+t3867+t3945-t3922-t4298-t6541+t4287+t4107-t4047+t4124-t3992;
+              const double t8362 = vertices[5](0)*vertices[4](2);
+              const double t8363 = -t4116+t4113-t4032+t4039-t3899+t6559+t6571+t6572+t6573-t6574-t6575+t6578-t6579+t8362-t6581-t6580;
+              const double t8374 = t352-t6560+t4505+t6562+t3914-t3995+2.0*t6581*zeta-t606+t3745*vertices[4](2)+t4684-2.0*t8362*zeta+t603*vertices[5](2)-t603*vertices[6](2)-t4448+t711*vertices[6](2)-t711*vertices[5](2);
+              const double t8378 = t3973+t3740*vertices[7](2)-t3740*vertices[4](2)-t3745*vertices[7](2)-t4681+t6090-t292-t3966+t3935+t4676-t6686+t6687-t3917-t3961+t358-t3952;
+              const double t8384 = t1794-t2593-t1307-t3076+t6698+t2662-t6699+t4540+t5017-t6700-t2536+t6702-t447-t7311+t1133+t635;
+              const double t8385 = t4958-t5039-t3625+t3627+t441-t4980+t4982+t4978-t5042-t3741-t3748+t3746-t4530+t4526+t3772-t6733;
+              const double t8393 = -t4620+t4558+t6734-t6735-t6736+t6737+t6738+t6739-t733-t3740*vertices[7](1)-t6740+t3740*vertices[4](1)+t4293-2.0*t1133*zeta+t3745*vertices[7](1)-t3745*vertices[4](1);
+              const double t8400 = -t5019+2.0*t7311*zeta-t711*vertices[6](1)+t711*vertices[5](1)+t603*vertices[6](1)-t603*vertices[5](1)+t5009-t4578+t309-t337+t2584+t6759-t2273-t6760+t2527-t1447;
+              const double t8406 = -t35+t12+t13-t415+t942-t578-t529+t540+t551-t557-t38+t42+t342-t57+t65+t72;
+              const double t8407 = -t75-t81+t85-t96+t419-t107+t2127+t78-t728-t2507+t105-t1509-t10+t25+t1609+t1450;
+              const double t8409 = t616*vertices[2](2);
+              const double t8410 = t597*vertices[3](2);
+              const double t8411 = t597*vertices[2](2);
+              const double t8414 = t616*vertices[3](2);
+              const double t8415 = t528*vertices[7](2);
+              const double t8416 = t528*vertices[6](2);
+              const double t8417 = -t83-t1440-t486+t653-t8409-t8410+t8411-2.0*t1050+t667+2.0*t1293-t1922+t8414-t8415+t1001+t8416-t368;
+              const double t8418 = t520*vertices[7](2);
+              const double t8419 = t520*vertices[6](2);
+              const double t8420 = t8418-t8419-t6846+t6847+t6848-t6849+t371-t506+t6851-t421+t459+t6859-t6860-t6862-t6865+t6866;
+              const double t8427 = -t3607+t293+2.0*t294+t299-t301-t316+2.0*t334*t692-t320-t327+t3615+t329;
+              const double t8433 = t3618-t332+t335-2.0*t736*t1293-2.0*t338-2.0*t339+t344+t347-t348+t3643+2.0*t359+t3651;
+              const double t8439 = t365-t334*t502-t388-2.0*t389+t403-t411-t6878+t366*t8411-t6018*t1694-t440-t3671+t3672;
+              const double t8444 = -t452+t463+t466-t468+t6018*t13+t470-t513*t502+2.0*t492-t496+t513*t636-t3693-t503;
+              const double t8456 = -t504+t6018*t506-t6018*t110+t512-t720*t435-t519+t4093*t165+2.0*t1365*t168+t1365*t174-t589*vertices[0](2)-t366*t8409;
+              const double t8458 = vertices[2](0)*vertices[3](1);
+              const double t8468 = -t1885*t187-2.0*t8458*t189+t1885*t189-t568*vertices[3](2)+2.0*t3707-t366*t8410+2.0*t549+t836*t838-t566-t720*t343+t571+t3718;
+              const double t8480 = -t584-t587-t588+2.0*t559*t128+2.0*t594+t412*t942-t596+t607-t720*t961-2.0*t1365*t1273+t720*t106-2.0*t560*t1001;
+              const double t8491 = -t3750+t631+t412*t91-t637+t720*t459-t1365*t165-t958*t174-2.0*t4093*t168-t4093*t174+t6217*t174-2.0*t609*t59-t642;
+              const double t8498 = -t645+t646+t649-t654+2.0*t1365*t692+t663-t665+t666+t671-t673+t620*t8414;
+              const double t8503 = -t3769-t3770+t678+t681-t685+t690+t6891-t3775-t3776+t6892+2.0*t595*t174+2.0*t18*t543;
+              const double t8512 = -t836*t16+t836*t96-t710-t836*t2480+t765*t1150-t595*t179+t724-t731+2.0*t735+t6901+t6904-t697*t1046;
+              const double t8518 = t741+t746+t697*t967+t3801-t750+t1549*t438+t595*t1167-t595*t1150-t765*t1167+t753-t3808-t6914;
+              const double t8531 = t759+t767-t770-t620*t8410-t6916-2.0*t252*t391+t334*vertices[7](2)+2.0*t349*t895+2.0*t413*t368-2.0*t785+t620*t8411;
+              const double t8539 = 2.0*t620*t1293+t3815-t6924-2.0*t620*t1922+t3821+t3822+t809-t6927+t814-t300*t616-t720*t91+t412*t2304;
+              const double t8552 = t390*t1564-t390*t1146-t390*t2132+t390*t2130+t3851-t3856-2.0*t483*t1293-2.0*t867+t3857+2.0*t483*t1922+t366*t8418-2.0*t872;
+              const double t8567 = -t366*t8419+2.0*t5266*t1551-2.0*t366*t1050+2.0*t878-2.0*t884+t6018*t435-t6018*t387-2.0*t323*t438-t483*t8414-t6018*t459+t897+t483*t8410;
+              const double t8583 = t483*t8409-t6960+2.0*t3266*t1273-t483*t8411+2.0*t768*t1273-t918+t836*t371-t836*t42+t476*t174-t1365*t306-t334*t306;
+              const double t8592 = -t922-t924+2.0*t290*t1050+t559*t547-2.0*t425*t1001-t290*t8416-t936-t1709*t838-t938+t1709*t42+t941+t944;
+              const double t8604 = -t946+2.0*t2022*t1001-t949+2.0*t620*t1001-t366*t8415+t955+t959+t3882+2.0*t366*t1001+t3885-2.0*t4093*t692+t366*t8414;
+              const double t8614 = t366*t8416-t982+t983-2.0*t736*t2247-t985+t1709*t2480+t366*t78-t3890-2.0*t992-t697*t997+t6018*t961-t6018*t106;
+              const double t8623 = t6998-t1000-2.0*t2187*t368+t1016+t6018*t343-t1024-2.0*t1025+t1032+t7014+t720*t81-t720*t84;
+              const double t8631 = -t1038-2.0*t1041+t3911-t720*t89+2.0*t1049-t290*t8418+t720*t92-t1054+t7023-2.0*t559*t79+t3912-t1069;
+              const double t8635 = t1070+t1071+t1074-t1077+t290*t8419+t1078-t7046-t1080+t7048-t3924-t778*t1937+t1085;
+              const double t8642 = t1091+t7050-2.0*t2187*t1050-t3926+t1093+2.0*t755*t1945-t755*t1564+t1099-t1100+t7052+t1103+t5830*t1772;
+              const double t8654 = -t1104+t755*t1146+t7053+2.0*t755*t661+t755*t2132-t755*t2130-t1109+2.0*t140*t1082-2.0*t1110-t3932-t3933;
+              const double t8661 = -2.0*t755*t477+t1123+t720*t387+2.0*t513*t692+t1129+t7073-t1132+t1136-t1138+t334*t303+t7077-t1144;
+              const double t8664 = t1145-t7079-t1147-2.0*t1148-t1149+t1151-t1154+t7087-t7088+t1157+t1163-t1168;
+              const double t8667 = vertices[2](2)*t340;
+              const double t8672 = -t778*t1178+t7097+t7099+t1189-2.0*t1192+t1196-t1199+t8667*t833-t8667*t822-t1200+t778*t1176+2.0*t1201;
+              const double t8679 = 2.0*t1204+t7104+t1213*t462-t3971-t778*t1206-t1216+t7115-t8667*t972+t1220-t3977-t1224;
+              const double t8683 = t3979-t7122+t1229-t1213*t1030-t1230+2.0*t1233+t1234-t1240-t3982+t1250+t5830*t623-t1254;
+              const double t8692 = -2.0*t1256-t5830*t517-t1260-t1264-t1265-t1268-2.0*t140*t1668+t1275-t1277+t1279-t778*t454-2.0*t589*t661;
+              const double t8697 = 2.0*t589*t591-t1291-t1292-t1296+t1298+t1299+t4006+t1305-t7146+t1309-t1310+2.0*t963*t661;
+              const double t8707 = -t1313+t1320-2.0*t963*t591-t1322+t1323+t1327+2.0*t1328-t7157+t1343-t1346-2.0*t1358;
+              const double t8711 = -t1359+2.0*t1360+t1361+t7172-t4053-t1370-t1375-t1376-t1377-2.0*t18*t2694-t1388+t1392;
+              const double t8718 = -t1398+2.0*t1402-t1406-t1409+t7191-2.0*t1413-t4077-t1416-2.0*t18*t2978+t334*t975+t4079+t7194;
+              const double t8727 = -t7195-2.0*t1424-2.0*t1425-2.0*t568*t1273+2.0*t568*t168+t1427-t1428+2.0*t1431-t5830*t1176-t1435-t4081+t1439;
+              const double t8735 = t1449-t7206-t1456+t5830*t1178+t5830*t1206-t5830*t1160+t5830*t454+t4097+t4098+2.0*t1467-t1469;
+              const double t8740 = -2.0*t1476-t4105-t1489+t4109+t7221+2.0*t18*t1301+t4112-t1500-t1502+t1505-t1507-t5830*t702;
+              const double t8743 = t7232+t1511+t5830*t725+t1513+t1515-t1517-t1519-t1524+t1528+t1535+t1536+t1542;
+              const double t8744 = t1544+t1545-t1546+t1553+t4142-t1555+t1556+t1557+t1561-t1565+t1566-t1568;
+              const double t8752 = -t7244-2.0*t1571+2.0*t1572+2.0*t1573+t1575+t4153+t4158+t1584+4.0*t1586+t4160+t1590;
+              const double t8753 = t1591-t1593-t4166-t4168-t7251-t1602-t1604+t7256+t4179-t1613-t1614+t1615;
+              const double t8757 = -4.0*t1616+t1619-t1622-t1624+t1629-t1630+t1632-t7262-t1633+t1634-2.0*t1636-t1637;
+              const double t8767 = t1638-2.0*t2708*t543-2.0*t499*t895+t1641-t7271+2.0*t2485*t895-t1649+t1652+t1655-2.0*t1656-t2363*t462+2.0*t1659;
+              const double t8772 = t4201-t1663-t1665+t2363*t1030+t4205-t4206+t300*vertices[7](1)+t1685-t1686-t1688+t1690;
+              const double t8779 = 2.0*t59*t610+t609*vertices[3](1)+t1692+t1695-t7281+t1698-t1699+2.0*t1700-t1703-t7288-t1706+2.0*t923*t174;
+              const double t8784 = t1713-t1714-t1715+t1720+2.0*t1723-2.0*t1774*t1273+t4223-t1733+t1737-t1738-t1739+t1741;
+              const double t8785 = t1744+t4234+t1746+t4236+t1751-t1753+t1755-t7302+t1758-t4242+t1768-t4243;
+              const double t8793 = t252*eta;
+              const double t8796 = t1769-2.0*t1549*t1551-t559*t942-t1773-t1775-t1780-t4252-t1781-t1787-2.0*t8793*t1055+t1788;
+              const double t8798 = t1789+t1790+t1791-t1792-t1801+t1803-t1806+t4278-t589*t176-t1810+t1812+t7328;
+              const double t8804 = t1817-t1822+2.0*t252*t1721-t1823-t1826-t1830-t1831-t1835-t1365*t296-t4300-t444*vertices[3](1)+t1840;
+              const double t8808 = 2.0*t1841-t1842+t1843+t1849+t2363*t2854+t1856-t1857-t4301+t1861-t2363*t610-t1864-t7352;
+              const double t8820 = t5830*t2874+2.0*t2708*t2978-t5830*t1027+t1867+t1869-t1871+t5830*t1937+2.0*t1872-t5830*t2907-2.0*t1873-2.0*t4308;
+              const double t8822 = t1874-t1879-t1882-t7360+t1884-t1774*t296-t4315-t1890-t4316+t1893-t1895+t7365;
+              const double t8825 = t1904+t4320-t1912-t1914-2.0*t1916+t1917+t1919-t1920-t7384-t1933+t1934+t4328;
+              const double t8829 = t7393-t1940+t7397+t1942-t1943+2.0*t1947-t4334+2.0*t4335+t4337+t1955+t1958-2.0*t1959;
+              const double t8840 = 2.0*t1961+t1962-2.0*t1964+t1968-2.0*t2708*t1301-t1973-t1975+2.0*t1981+2.0*t18*t2824-t1986-t4353;
+              const double t8846 = t1993+2.0*t560*t1050-t1995-t1996+t2001-2.0*t2006-2.0*t755*t591+t4360+t2014-t2016+t4374+t4375;
+              const double t8851 = -t4376+t4377-t7445-t6018*t81+t6018*t89+t4378-t7446-t2039+t6018*t84+t2042-t7452+t2046;
+              const double t8860 = -t6018*t92-t7460-2.0*t2060+t2062+2.0*t736*t2388-2.0*t2067+2.0*t2070-t2075+t2076+t2079-2.0*t2087-t6018*t83;
+              const double t8866 = t2090-t2091-t4390-t2096+t2098+t2099+t2105-t2108-2.0*t638*t174+t2111+t2114-t360*t975;
+              const double t8876 = t2123+2.0*t8458*t187-t8458*t196+t8458*t198+t2129+t8458*t176-t2135-t2136-t2138-t8458*t162+2.0*t18*t788+t483*t728;
+              const double t8886 = -t768*t303-t4416-2.0*t2146+t768*t296+t2148+2.0*t2187*t667+t768*t306-t2151+t7485-t765*t174+t2152-t412*t2295;
+              const double t8897 = t589*vertices[4](2)-t2153+t559*t2018+t7490-t483*t78-2.0*t586*t296+t586*t975-t290*t8411+t586*t303+t2162-t328*vertices[7](2)-t586*t306;
+              const double t8909 = 2.0*t2166+t2168+t2172-t8458*vertices[4](2)-t720*t386-t720*t105-t2183+t7494+t720*t114-t7495-t2192;
+              const double t8915 = t720*t44-2.0*t2195+t720*t342-t2201+t4457+t4458+t4464-t323*t528-t4467+4.0*t2213-t2216-t4470;
+              const double t8919 = -t2218-t4471-t2221+t2222+t323*t520-t2225+t2227+t4480+t4481+t4482-t360*t303-t2242;
+              const double t8930 = t4483+t864*vertices[3](2)+t360*t306-4.0*t2249+2.0*t360*t296+t483*t8415+t4490-t4491-t620*t8409+t6217*t636-t2261-2.0*t156*t895;
+              const double t8939 = -2.0*t6217*t1273+t2270+t2277-t1709*t371-t4499-t7538+t2287+t2294+t4093*t502-t559*t114+t559*t105;
+              const double t8943 = -t4093*t636-t2299+t7554+t2310+t8458*vertices[0](2)-t2315-t2317-t720*t35+t2320-t2321+t4519-t2323;
+              const double t8948 = -t2324+t2325+t2328-t2330+t2338-t4537-t6018*t342-t2340+t2342+t8667*t970-t1365*t502-t2343;
+              const double t8954 = t7567+t2346-t2347+2.0*t2348+t2349+t6018*t91+t1365*t636+t958*t502-t4545+t2359-t2361-t1774*t306;
+              const double t8968 = -t2368-2.0*t958*t692+t1252*t174-t2371-2.0*t586*t311+t778*t1160+t1774*t303+t513*t179-t958*t636-t513*t165+t7584;
+              const double t8980 = t778*t1164-2.0*t5077*t895+t2385+2.0*t958*t1273+t2391-t2392-t755*t189-t6217*t502-t620*t728-4.0*t2395-t2399+2.0*t6217*t692;
+              const double t8986 = -t2400+t4569+t7600+t4575+t2409-2.0*t483*t1001+t4576+2.0*t2411-t2412-t4581-t483*t8416+t2418;
+              const double t8999 = t2419-t2420-2.0*t252*t1127+t778*t1027+2.0*t8793*t391-t1213*t2854+t755*t187+t1213*t610+t589*t162+2.0*t7018*t1301-t778*t2874+t2434;
+              const double t9011 = t778*t2907-t697*t970+t697*t972+t6018*t105-t2446+2.0*t483*t1050-t483*t8418-t2451+t2454+t6018*t35-t6018*t114;
+              const double t9015 = -t6018*t44-t2463+t4615-t2466+t483*t8419-t2468+t2472+t2474+t2475-2.0*t2476+t2477-t2478;
+              const double t9020 = -t7644-t2487+t2489-t330*t597-t4625+t7661-t2510-t559*t83+t2513+t2514+t559*t91-t4637;
+              const double t9026 = -t7670+t2519-t2521-t2522+t2524+2.0*t736*t1050-t2526+t4638+t4640-t412*t83+t2534-2.0*t736*t667;
+              const double t9041 = t6018*t386-t778*t725+t778*t702-t778*t623+t328*t165-t7686+t778*t517+2.0*t5077*t2717+2.0*t2550-t328*t179-t2556;
+              const double t9047 = vertices[2](0)*vertices[6](1);
+              const double t9051 = -t2557-t2562-2.0*t620*t1050+t2566-2.0*t5077*t789-t2572-2.0*t2575+t9047*t1146-t4656-t4660+t720*t83-t290*t78;
+              const double t9058 = t9047*t2132-t366*t728-t2587+2.0*t2588-t9047*t2130+t7706+t2596+t4663-t412*t114-t2601-t2604+t2610;
+              const double t9066 = t2611+t412*t105-t4667+t2617-t589*t198+t362*t528-t2622+t323*t15+2.0*t2624+t620*t8418-t620*t8419+t7719;
+              const double t9077 = t2626-t2627-2.0*t768*t168+t1774*t174+2.0*t8458*t661-t2634+t7726+t349*t542+t638*t179-t476*t1150+t2640;
+              const double t9088 = t476*t1167+t638*t1150-t7729-t638*t1167-t2641-2.0*t8458*t477-t495*t616+t2646-t7733+t495*t597-2.0*t8458*t591-t495*t600;
+              const double t9097 = t2655+t2657-t2658+t2660-t2661+t330*t616+2.0*t8458*t1945-t8667*t967+t8667*t1046-t4696-2.0*t2669-t559*t540;
+              const double t9111 = t958*t296-t559*t545+t958*t306+t4700-t140*t1027+2.0*t222*t868+t697*t513-t233*t1444+t860*t616+t860*t600+t8667*t417-2.0*t300*t600;
+              const double t9121 = t300*t191-t894*t324-t8667*t586+t8667*t595-t4702-t140*t300-t4707-t7769+t7771-t2699+4.0*t2700;
+              const double t9129 = t156*t788-t2705+t778*t379-t4715-t778*t444+t4717-t778*t509-t4720-t9047*t1564+t778*t300+t4732-2.0*t4733;
+              const double t9138 = t2725-t7781+t4735+2.0*t412*t84+t7793+2.0*t412*t89+t4740-t5830*t379-t7797+t4746+t5830*t444+t5830*t509;
+              const double t9150 = -t5830*t300-t5830*t887-2.0*t412*t92-t417*t179-2.0*t412*t96-t2766+t2770-t7829+2.0*t2779+t4759-t1820*t174-2.0*t413*t667;
+              const double t9159 = t2788-2.0*t334*t296+t7835-t4764-t3266*t174+t2801+t4768+t559*t578-t2804-t568*t165+t568*t174;
+              const double t9167 = t140*t454-t4770+t559*t521-t7848+2.0*t2817-2.0*t2820+t778*t887-t559*t526-t2828+t7856+t559*t529-t7857;
+              const double t9178 = -t958*t303+t2834+t2841+t7863+t7864-2.0*t383*t692-t1820*t1167-t412*t578-2.0*t412*t106-t4784-t328*t636-t383*t636;
+              const double t9185 = -t2850-t7875-t7877+2.0*t589*t477-t2857-t412*t521+t328*t502-t2866+t2870-t1709*t96+t1709*t16+t4802;
+              const double t9194 = t412*t526-t412*t529-t2889+t2890+t4804-t7902-t2893-t4806-t2896-t4809+2.0*t2903;
+              const double t9201 = t412*t540+2.0*t2909+2.0*t2910+t412*t545+t2912-2.0*t2913+t4820-t412*t547+t4822+t4823-t7923+t4825;
+              const double t9212 = -t4827-2.0*t412*t81-t963*t189+t2943-2.0*t2944+t290*t8410-t7929-t4844-t2949-2.0*t290*t1293-2.0*t589*t187-t2951;
+              const double t9223 = t2952+t4846+t2954-t2957+2.0*t290*t1922-t2964+2.0*t589*t189+t589*t196+t768*t165-t768*t174+t8667*t328-2.0*t404*t406;
+              const double t9234 = t8667*t984-t7949-t2989-2.0*t2994-t7968+2.0*t404*t409-t3001+t1365*t303+t3004+2.0*t3008+2.0*t330*t600;
+              const double t9245 = -t4865+t290*t8415-t330*t191-t4867-t349*t788+2.0*t3022-2.0*t290*t1001+t586*t179-t923*t1150+t923*t1167-t923*t179-t3028;
+              const double t9249 = t4873+t3033-t3035+t1820*t1150+t4875+t383*t502-t3037-t3041+t3043+t3047+t4877-t3051;
+              const double t9253 = 2.0*t412*t16+t3064-t4881-t4883+t3065+t3070+t7986+t3075+t3078+t140*t509+t3084+t4890;
+              const double t9262 = -t3085+t290*t728-t328*t303-t697*t833+t697*t822+t328*t306+t3088-t3089-t3090-t3091-t4892;
+              const double t9268 = t3092+t3093+t3094-t8667*t852-t4894+t3095+2.0*t328*t296+t3102-t7988+t4903-t290*t8414-t328*t975;
+              const double t9274 = t3116-t3118+2.0*t3123+t290*t8409+t963*t187+t4906+t3128+t3130+t3133-t360*vertices[7](2)+t3135-t3137;
+              const double t9279 = -t3139-t923*vertices[3](2)+t3141+t3142-t778*t1772+t3150+t3155-t3160-t3164-t831*t438+t559*t1509+t3175;
+              const double t9290 = -t156*t542-t559*t1609-2.0*t18*t542-t7998+t3184-t3185+2.0*t736*t728-t559*t653+t620*t78-t4921-t4926;
+              const double t9298 = t3206+t559*t486+t4930+t720*t1064-t4934-t720*t115-2.0*t560*t1293+t4941-t3232+t4942+2.0*t560*t1922+t3235;
+              const double t9307 = t3236+t3238+t3240-t4943+2.0*t252*t1055+2.0*t3248-t8007-t836*t421+t4944-t4945+t836*t120+2.0*t412*t42;
+              const double t9320 = -2.0*t3255+t697*t384+t3258-t3261-2.0*t404*t508+t404*t71+2.0*t404*t324+t894*t508-t5266*t438+t609*t51+t362*t438-t362*t520;
+              const double t9331 = -t222*t586+t222*t417-t697*t417-t404*t5+t3262+t3265-t3269-t3271+2.0*t412*t13+t8011+t4963;
+              const double t9340 = -t4964-t3275+t3278+t3279-t3280+2.0*t412*t115-t1365*vertices[3](2)+t586*vertices[7](2)-2.0*t412*t120-t412*t1509-t595*vertices[3](2)+t3306;
+              const double t9352 = t5002-t3308-2.0*t3309+t3310+t412*t1609-t444*t520+2.0*t444*t438-t444*t15+t831*t520-t831*t528-t860*t597+t300*t597;
+              const double t9361 = t233*t755+t697*t852-t697*t984+t222*t328-t222*t513-t697*t328+t697*t638+t444*t528-t3311+t3312-t5008+t3315;
+              const double t9374 = t3317+t412*t653-t412*t486+2.0*t6899*t964-t620*t8415-t3329-t330*vertices[7](1)+t768*vertices[3](2)+t720*t1694-t720*t13+t697*t586;
+              const double t9387 = -t697*t595-t864*t1167+t864*t1150+t1252*t1167-t1252*t1150+t864*t179-2.0*t864*t174-2.0*t412*t110+t8037-t559*t2304-t3355+t559*t2295;
+              const double t9397 = t323*vertices[3](1)-t412*t2018-t5059+t4093*vertices[3](2)+t412*t937-t559*t937+t3363-t1029*vertices[3](1)-t3365-t720*t506+t3366-t404*vertices[4](1);
+              const double t9411 = t5064+t404*vertices[0](1)+t720*t110+t638*vertices[3](2)-2.0*t222*t756-2.0*t6899*t1152+2.0*t736*t368+t5066+2.0*t1885*t477-t3374+2.0*t1885*t591+t8044;
+              const double t9421 = -t8667*t384+t620*t8416-t5071+t1885*t1564-t1885*t1146-t5075-t3382+t3384+t3386-t1885*t2132+t1885*t2130;
+              const double t9431 = -2.0*t1885*t661+t8049-t3398-t3400+2.0*t3401-2.0*t3405-2.0*t1885*t1945+t5082+t3411-t3412-2.0*t3414-2.0*t328*t692;
+              const double t9436 = -t3416+t3420+2.0*t328*t311+t3423+t6018*t115-t5085+t8055-t5087+t5089-t5091-t5096-t3427;
+              const double t9445 = t8060-t8061+2.0*t4093*t1273-t3432-t6018*t1064+t8667*t997-t5100+2.0*t3434+2.0*t1029*t59-t1029*t51-t5101+t3437;
+              const double t9455 = -t5102-t5103+2.0*t2187*t1293+t3446-2.0*t3447+t3449-t8066-t230*t755+2.0*t366*t1293+t8069-2.0*t3454-t3456;
+              const double t9468 = -2.0*t366*t1922-t3459-t3461+2.0*t252*t1444-2.0*t252*t755-2.0*t2022*t1922-t5110-t8072-2.0*t979*t16+t3468+t8073+2.0*t425*t1922;
+              const double t9478 = -t5116+t3472-t5830*t1164-t3475-2.0*t979*t42+2.0*t3478+t1709*t421+t5120-2.0*t736*t78+2.0*t5134-t5135+t5136;
+              const double t9485 = -t5138-t5139+t5140+t5193-2.0*t5198-t5199-t1709*t120-t5209+t230*t1444-t8667*t513-t8667*t638+t334*t636;
+      s1 = t8948+t8804+t8822+t8866+t8772+t9455+t9121+t9331+t9088+t8779+t9340+t8784+t8661+t9129+t8444+t8785+t8886+t9485+t8672+t8796+t8642+t8954+t8915+t9138+t8679+t8798+t8683+t9150+t9352+t8909+t8735+t8808+t8692+t8968+t8820+t9159+t8707+t8825+t9374+t8829+t8986+t8840+t9290+t9178+t8846+t9097+t8623+t8711+t9387+t9223+t9185+t8654+t8614+t8999+t9397+t9361+t8851+t8664+t8635+t8697+t8860+t8439+t9011+t8876;
+              const double t9492 = s1+t8433+t9411+t9020+t8518+t9015+t8531+t9026+t8897+t8539+t8727+t8552+t9212+t9421+t9431+t8567+t8456+t8930+t9194+t9436+t8939+t9041+t8468+t9445+t9111+t8480+t8919+t9201+t8583+t9051+t8743+t8740+t8744+t8631+t8491+t8498+t9468+t8427+t9167+t9066+t9478+t8503+t8752+t8592+t8980+t9058+t8604+t8512+t8757+t8718+t8753+t8943+t9077+t8767+t9234+t9245+t9249+t9253+t9262+t9268+t9274+t9279+t9298+t9307+t9320;
+              const double t9495 = t5383-t5384+t1977-t1997-t5391+t5392-t2500+t1991+t5398-t5399-t5400+t5401+t5402-t5403-t5406-t542;
+              const double t9496 = t5451+t947+t353-t5244+t5253-t623-t1176-t467+t8089-t806+t8091-t8092+t610-t8093-t8095+t8101;
+              const double t9502 = -t462+t8104+t788+t725-t8105+t444+t1098-t8109+t1301-2.0*t789-t2978+t8110-t8094*vertices[3](2)+t1785*vertices[6](2)+t2717-t1785*vertices[7](2);
+              const double t9509 = -t3031*vertices[6](2)+t3031*vertices[7](2)+t5375*vertices[3](2)-t895+2.0*t543+t8094*vertices[2](2)-t5375*vertices[2](2)-t647-t887+t1202-t437+t1027+t5482-t509+t1160-t5493;
+              const double t9519 = t3031*vertices[6](1)+t5505-t569+t643+t1785*vertices[7](1)-t970+t8094*vertices[3](1)-t1785*vertices[6](1)-t5529-t1152+t5540+t384-t5548+t497-t706-t734;
+              const double t9525 = -t5695+t5696-2.0*t1444*xi-t8094*vertices[2](1)+t1055+t5375*vertices[2](1)+t5697-t5698-t5701+t5702-t5375*vertices[3](1)+t964-t5703+t5704-t5705-t5709;
+              const double t9529 = t5710-t5711+t5712+t513-t5718+t481+t5719+t1444+t5727+t489-t755-t469+t8120+t595-t417+2.0*t755*xi;
+              const double t9531 = -t391-t3031*vertices[7](1)-t638+t766+t8127-t8128-t967+t8133-t8136-t396-t8138-t8139+t8142+t833+t8143-t8144;
+              const double t9537 = vertices[2](1)*vertices[3](2);
+              const double t9538 = -t54-t56+t5817-t122-t137-t5818+t142+t146+t153-t5819+t157+t5821+t3928-t9537+t5882-t3849;
+              const double t9546 = t3832+t3843-t3829-t3847+t5823-t5825+t5827-t5831-t2363*vertices[6](2)+t2363*vertices[2](2)-t4602-2.0*t5882*eta+t4606+t51*vertices[2](2)-t1213*vertices[2](2)+t1213*vertices[6](2);
+              const double t9552 = t4594+t5830*vertices[7](2)+2.0*t9537*eta-t151*eta+t5835-t5842+t5844-t5846+t5886-t3818+t5887-t5889+t5890+t3784-t5892+t5893;
+              const double t9556 = -t5894+t5896-t5884-t119-t3839-t5906-t5907+t5864+t274-t88+t154+t3803-t3891+t778*vertices[3](2)-t5830*vertices[3](2)-t778*vertices[7](2);
+              const double t9562 = vertices[2](0)*vertices[3](2);
+              const double t9568 = -t3964+t6014+t4572+t5233-t6015-t5236+t6016+t4134-t9562+t404+t4560+t836*vertices[6](2)-t4543-2.0*t404*eta-t6018*vertices[3](2)+t6018*vertices[7](2);
+              const double t9578 = t720*vertices[3](2)-t720*vertices[7](2)+t1709*vertices[2](2)+t412*vertices[2](2)-t836*vertices[2](2)+2.0*t9562*eta-t5228*eta-t1709*vertices[6](2)-t3947-t3937-t4027+t3940-t4198+t3942-t4169+t4172;
+              const double t9580 = -t4021+t4196+t6019-t6022+t6024-t6026+t6029-t6030-t6031+t6032-t6090-t6038+t5271+t292+t3864+t6174;
+              const double t9581 = t6179-t6184-t4546+t3969-t6185-t6186+t4155-t6187+t6188+t6189-t6191+t6193-t6194+t860-t1029-t330;
+              const double t9587 = -t4306-t1258+t3481+t3837-t6203-t1407+t6204+t1859-t6205-t5561+t6207-t360+t768+t334+t1783-t1365;
+              const double t9602 = -t589-t6018*vertices[7](1)-t720*vertices[3](1)+t720*vertices[7](1)-2.0*t8458*eta-t3861-t412*vertices[2](1)+t836*vertices[2](1)+t1709*vertices[6](1)-t1709*vertices[2](1)+t1885*eta+t6018*vertices[3](1)+t4350-t836*vertices[6](1)+2.0*t589*eta-t3764;
+              const double t9604 = -t309+t337-t3114+t1403+t6349-t6350+t6351+t6361-t6362-t6365-t6366-t1815+t400+t6367-t3903+t4693;
+              const double t9605 = t3623-t4971+t6210-t6211-t6216+t6224-t6227+t6229-t6231+t6232+t3762+t5033-t5049+t8458+t6369-t6370;
+              const double t9615 = -t6379-t35+2.0*t4+t7+2.0*t9+t12+t13-2.0*t19+t6380-t24-t27-2.0*t29-t32+t37-t39+t41+t42+t54+t342;
+              const double t9616 = t56-t58+t66-t68+t73-t75-t80-t81+t84+t87-t96-t101-t102+t104-t106+t122+t129-t130+t137;
+              const double t9623 = t139+t141-t142-t146+2.0*t152-t153+t155-t157-2.0*t158-t159+t160-t164+t3502+t6435-t3504+2.0*t180-2.0*t181+t3505-2.0*t184;
+              const double t9624 = t185-t186+t6445+t6446-t6448-t205+t207+t208-t209+t211-t213+t214-t216+t217-t218+t219-t5866-t5869+t5871-t244;
+              const double t9627 = -t246+t248-t253+t256+t258-t6488-t6491+t6492-t5881+t5883-t5885-t4437+t3818-t4591+t5888-t3784+t3681+t5895+t5884;
+              const double t9628 = t119+t8170-t6496+t8171+t105+t8172+t8173-t8174-t6497-t5952-t8175+t8176+t5959+t6498-t8177+t8180+t5965+t5967-t5971;
+              const double t9630 = -t6500-t264-t5976+t5978+t8181-t8182-t266+t268-t8183+t6501+t271-t8184-t83-t3-t274+t275-t277+t88-t154;
+              const double t9633 = -2.0*t20+t281-t283+2.0*t1-t285+t28-t8189+t8191-t8193+t8194+t6517-t8195-t8196+t371-t458-t506+t1064-t421+t459-t343;
+              const double t9641 = -t8204+t5224+t5227+t3964-t3793+2.0*t5229+t5230-t4572-t4018-t5233+t5234+t8208-t8209-t8211+t5236-t5237+t5238-t5239+t8212;
+              const double t9644 = t5241-t6560+2.0*t4505+t5242+t6562+t4050-t5244+t5245-t4043+2.0*t3914-t4134+t510-t623-t5255-t1176-t467-t5259+t610+t2874;
+              const double t9649 = -t462+t3947+t725-t445+t444+t1098-t8218+t6622-t8219+t8220-2.0*t4681+t8221-t6662+t4021+t4135-t6062-t6064-2.0*t6065+2.0*t6066;
+              const double t9656 = t6069+t6671-2.0*t6079+2.0*t6090-t5269-t6672+2.0*t6096+2.0*t6099-2.0*t6100+t6107+t6673-2.0*t6109-t5271-t8227+t8228-t8229+t5273-t6146+t6150-t6675;
+              const double t9662 = t8230+t5276+t6157-t6159-t8231+t8232-t3864-2.0*t3966-t887+t5278+t5282-t5284+t5287+t8234-t5288-t5476-2.0*t5301+t8236-2.0*t5302;
+              const double t9671 = t5477-t5478+t6679+t8238+t4680+t1027-t323-2.0*t5309+t6680-2.0*t5312-t6682+2.0*t5314+t5482-t509+2.0*t5318-2.0*t5320+2.0*t5321+2.0*t850-2.0*t848;
+              const double t9678 = -2.0*t1182+t1160-2.0*t5326-t6563-t8248+t6564+t8251-t5488+t5491-t6685+2.0*t5337-2.0*t5338+t5492-t1937+2.0*t5340-t6686-t5494+t6687+t6184;
+              const double t9683 = -t8254+t8255-t8257-t8258-t8259-t6193+t8260-t6689+2.0*t5344+t5354-t5356+t5360-t5362-t860-2.0*t3798-t609+t1029+2.0*t358+t330-2.0*t3952;
+              const double t9694 = t923-t864+t5505-t5506-t569+t5509-t5511+2.0*t1794+t1653-t5515+t4306-t5516-2.0*t1307-t5519-2.0*t3076+t6698-t970+2.0*t2662+t5523;
+              const double t9695 = -t6699+t5524+t5526-t5529-t6238+t6240+t8273-t8274+t5535+t5536-t5537+t5539+t1258+t5545+t384-t5547-t5549+t497-t5555;
+              const double t9699 = -t5556-t3481-t3837+t4517+t1407-t2292-t2240+2.0*t3443-t1859+t1701+t2619-2.0*t1886+t5561-t5562-t8282+t8283+t5564-t5566+t5568;
+              const double t9704 = -t5570-t5572+t5574+t513+t5580+t360-t768+t5582-t5584+t5586-t5588-t8287+t8289-t5725-2.0*t5611+t5726+2.0*t5614+2.0*t489-2.0*t5621-t6726;
+              const double t9712 = 2.0*t5623-2.0*t5624+2.0*t5625+t5632-2.0*t447-t334+t5636-t5638-t5639+t568+t5649-t1783-t4093+t1365-t5656+2.0*t441+t5660-t5662+t5664;
+              const double t9713 = -t5668+t5670-t5672+t5674+t8300-t5680-t8301-t8302+t8303+t6264-t6266+t6742-t8304+t595+t8305-t8306+t6301-t6303-t6744;
+              const double t9715 = t8309+t8310+t6745-t8311-t8312-t417-t8313+t8314+t8315-t6758+t8316+t8317-t8318+t6759-t8319-t6760-t6349+t8320+t8321;
+              jacobians_grad[point][0][0][0] = -(t47+t94+t136+t171+2.0*t202+2.0*t228+t267+t286)*t3493+t3606*t5219;
+              jacobians_grad[point][0][0][1] = (t5235+t5248+t5265+t5295+2.0*t5317+2.0*t5328+2.0*t5346+t5369)*t3493-t5501*t5219;
+              jacobians_grad[point][0][0][2] = (t5520+t5541+t5560+t5576+t5609+2.0*t5627+t5652+t5686)*t3493-t5814*t5219;
+              jacobians_grad[point][0][1][0] = (t5820+t5828+t5843+t5852)*t3493-t6011*t5219;
+              jacobians_grad[point][0][1][1] = -(t6017+t6020+t6036+t6048)*t3493+t6200*t5219;
+              jacobians_grad[point][0][1][2] = -(t6206+t6208+t6223+t6233)*t3493+t6376*t5219;
+              jacobians_grad[point][0][2][0] = (t6382+t6384+t6391+t6405)*t3493-t6537*t5219;
+              jacobians_grad[point][0][2][1] = -(t6540+t6551+t6561+t6565)*t3493+t6695*t5219;
+              jacobians_grad[point][0][2][2] = -(t6701+t6703+t6710+t6718)*t3493+t6840*t5219;
+              jacobians_grad[point][1][0][0] = -(t6843+t6844+t6854+t6867)*t3493+t3606*t8085;
+              jacobians_grad[point][1][0][1] = (t8088+t8097+t8108+t8113)*t3493-t5501*t8085;
+              jacobians_grad[point][1][0][2] = (t8119+t8121+t8131+t8147)*t3493-t5814*t8085;
+              jacobians_grad[point][1][1][0] = (t8156+t8157+t8163+2.0*t8164+2.0*t8167+t8178+t8187+t8197)*t3493-t6011*t8085;
+              jacobians_grad[point][1][1][1] = -(t8213+t8215+t8222+2.0*t8223+t8235+t8246+t8256+t8264)*t3493+t6200*t8085;
+              jacobians_grad[point][1][1][2] = -(t8272+t8276+t8284+t8293+t8299+t8307+t8322+t8331)*t3493+t6376*t8085;
+              jacobians_grad[point][1][2][0] = (t8341+t8352+t8354+t8355)*t3493-t6537*t8085;
+              jacobians_grad[point][1][2][1] = -(t8361+t8363+t8374+t8378)*t3493+t6695*t8085;
+              jacobians_grad[point][1][2][2] = -(t8384+t8385+t8393+t8400)*t3493+t6840*t8085;
+              jacobians_grad[point][2][0][0] = -(t8406+t8407+t8417+t8420)*t3493+t3606*t9492;
+              jacobians_grad[point][2][0][1] = (t9495+t9496+t9502+t9509)*t3493-t5501*t9492;
+              jacobians_grad[point][2][0][2] = (t9519+t9525+t9529+t9531)*t3493-t5814*t9492;
+              jacobians_grad[point][2][1][0] = (t9538+t9546+t9552+t9556)*t3493-t6011*t9492;
+              jacobians_grad[point][2][1][1] = -(t9568+t9578+t9580+t9581)*t3493+t6200*t9492;
+              jacobians_grad[point][2][1][2] = -(t9587+t9602+t9604+t9605)*t3493+t6376*t9492;
+              jacobians_grad[point][2][2][0] = (t9615+t9616+t9623+2.0*t9624+2.0*t9627+t9628+t9630+t9633)*t3493-t6537*t9492;
+              jacobians_grad[point][2][2][1] = -(t9641+t9644+t9649+t9656+t9662+t9671+t9678+t9683)*t3493+t6695*t9492;
+              jacobians_grad[point][2][2][2] = -(t9694+t9695+t9699+t9704+t9712+t9713+t9715-t8331)*t3493+t6840*t9492;
+};
+};
+
+
+#endif
index e7034ba43079e9aa8f45c77db1c82d6418be85e7..84d6ad4c1cceaf7e022b976b88c623a72e94bd22 100644 (file)
@@ -5,6 +5,8 @@
 #  Wolfgang Bangerth, 1998
   
 perl -pi -e 's/phi_polynom\[(\d+)\] =/case $1: return/g;' *2d_shape_value
+perl -pi -e 's/xi/p(0)/g; s/zeta/p(2)/g; s/eta/p(1)/g;' *2d_shape_value
+
 perl -pi -e 's/\[(\d+)\]\[(\d+)\]/($1,$2)/g;' *2d_massmatrix
 perl -pi -e 's/(t\d+) =/const double $1 =/g;' *2d_massmatrix
 perl -pi -e 's/\[(\d+)\]\[(\d+)\]\[(\d+)\]/[$1]($2,$3)/g;' *2d_prolongation
@@ -24,9 +26,10 @@ perl -pi -e 's/x\[(\d)\]/vertices[$1](0)/g;' *2d_inverse_jacobian_grad
 perl -pi -e 's/y\[(\d)\]/vertices[$1](1)/g;' *2d_inverse_jacobian_grad
 perl -pi -e 's/inverseJacobian/jacobians_grad[point]/g;' *2d_inverse_jacobian_grad
 
-perl -pi -e 's/([^;])\n/$1/g;' *2d_shape_grad
+perl -pi -e 's/([^;])\n/$1/g;' *3d_shape_grad
 perl -pi -e 's/grad_phi_polynom\[(\d+)\]\[0\] = (.*);/case $1: return Point<2>($2,/g;' *2d_shape_grad
-perl -pi -e 's/grad_phi_polynom\[(\d+)\]\[1\] = (.*);/$2);/g;' *2d_shape_grad
+perl -pi -e 's/grad_phi_polynom\[(\d+)\]\[[12]\] = (.*);/$2);/g;' *2d_shape_grad
+perl -pi -e 's/xi/p(0)/g; s/zeta/p(2)/g; s/eta/p(1)/g;' *2d_shape_grad
 
 
 #    concatenate all lines for each entry
index f33f0257aa8b6f3ae87c5df6883c03071b02f194..afcc425b59f450eeb5c79f30dfb3eb2a6f9d914f 100644 (file)
   C(local_mass_matrix,      filename=linear3d_massmatrix):
   C(interface_constraints,  filename=linear3d_constraints):
   C(real_points, optimized, filename=linear3d_real_points):
-  C(inverseJacobian,        filename=linear3d_inverse_jacobian):
-  C(grad_inverseJacobian,   filename=linear3d_inverse_jacobian_grad):
+  # the following two files get much smaller and faster when processed using 'optimized'
+  C(inverseJacobian,        optimized, filename=linear3d_inverse_jacobian):
+  C(grad_inverseJacobian,   optimized, filename=linear3d_inverse_jacobian_grad):
+
+
index 219b0682454fab94c9da01339f512ae06fa9c587..9a27c773b2968c9bcf8840f36624d54d76e8e922 100644 (file)
@@ -20,57 +20,56 @@ support_points_fill_lines := proc (starting_index, dofs_per_line, support_points
 
   # line 0
   for i from 1 to dofs_per_line do
-    print (next_index+i-1):
-    support_points[next_index+i-1] 
+    support_points[next_index] 
       := array (1..3, [i*increment, 0, 0]):
     next_index := next_index+1
   od:
 
   # line 1
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [1, 0, i*increment]):
     next_index := next_index+1
   od:
 
   # line 2
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [i*increment, 0, 1]):
     next_index := next_index+1
   od:
 
   # line 3
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [0, 0, i*increment]):
     next_index := next_index+1
   od:
 
   # line 4
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [i*increment, 1, 0]):
     next_index := next_index+1
   od:
 
   # line 5
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [1, 1, i*increment]):
     next_index := next_index+1
   od:
 
   # line 6
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [i*increment, 1, 1]):
     next_index := next_index+1
   od:
 
   # line 7
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [0, 1, i*increment]):
     next_index := next_index+1
   od:
@@ -78,29 +77,120 @@ support_points_fill_lines := proc (starting_index, dofs_per_line, support_points
 
   # line 8
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [0, i*increment,0]):
     next_index := next_index+1
   od:
 
   # line 9
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [1, i*increment, 0]):
     next_index := next_index+1
   od:
 
   # line 10
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [1, i*increment, 1]):
     next_index := next_index+1
   od:
 
   # line 11
   for i from 1 to dofs_per_line do
-    support_points[next_index+i-1
+    support_points[next_index] 
       := array (1..3, [0, i*increment, 1]):
     next_index := next_index+1
   od:
-end:
\ No newline at end of file
+end:
+
+
+
+
+support_points_fill_quads := 
+  proc (starting_index, dofs_per_direction, support_points)
+
+  local next_index, increment, i,j:
+
+  next_index := starting_index:
+  increment := 1/(dofs_per_direction+1):
+
+  # face 0
+  for i from 1 to dofs_per_direction do
+    for j from 1 to dofs_per_direction do
+      support_points[next_index]
+        := array (1..3, [j*increment, 0, i*increment]):
+      next_index := next_index+1:
+    od:
+  od:
+
+  # face 1
+  for i from 1 to dofs_per_direction do
+    for j from 1 to dofs_per_direction do
+      support_points[next_index]
+        := array (1..3, [j*increment, 1, i*increment]):
+      next_index := next_index+1:
+    od:
+  od:
+
+  # face 2
+  for i from 1 to dofs_per_direction do
+    for j from 1 to dofs_per_direction do
+      support_points[next_index]
+        := array (1..3, [j*increment, i*increment, 0]):
+      next_index := next_index+1:
+    od:
+  od:
+
+  # face 3
+  for i from 1 to dofs_per_direction do
+    for j from 1 to dofs_per_direction do
+      support_points[next_index]
+        := array (1..3, [1, j*increment, i*increment]):
+      next_index := next_index+1:
+    od:
+  od:
+
+
+
+  # face 4
+  for i from 1 to dofs_per_direction do
+    for j from 1 to dofs_per_direction do
+      support_points[next_index]
+        := array (1..3, [j*increment, i*increment, 1]):
+      next_index := next_index+1:
+    od:
+  od:
+
+  # face 5
+  for i from 1 to dofs_per_direction do
+    for j from 1 to dofs_per_direction do
+      support_points[next_index]
+        := array (1..3, [0, j*increment, i*increment]):
+      next_index := next_index+1:
+    od:
+  od:
+end:
+
+
+
+
+support_points_fill_hex := proc (starting_index, dofs_per_direction, support_points)
+
+  local next_index, increment, i, j, k:
+
+  next_index := starting_index:
+  increment := 1/(dofs_per_direction+1):
+
+  for i from 1 to dofs_per_direction do
+    for j from 1 to dofs_per_direction do
+      for k from 1 to dofs_per_direction do
+        support_points[next_index]
+          := array (1..3, [k*increment,
+                           j*increment,
+                           i*increment]):
+        next_index := next_index + 1:
+      od:
+    od:
+  od:
+end:
index d783b63f0e3328ed671d974d0216bae1e3f31be9..1f26bb73e1657e57b847e5f7d6a992c7f3d25fcf 100644 (file)
@@ -35,16 +35,20 @@ perl -pi -e 's/.*= 0.0;\n//g;' *3d_restriction
 perl -pi -e 's/\[(\d+)\]\[(\d+)\]/($1,$2)/g;' *3d_constraints
 perl -pi -e 's/.*= 0.0;\n//g;' *3d_constraints
 
-perl -pi -e 's/^\s*t/const double t/g;' *3d_inverse_jacobian
+perl -pi -e 's/([^;])\n/$1/g;' *3d_inverse_jacobian
+perl -pi -e 's/^\s*t/              const double t/g;' *3d_inverse_jacobian
 perl -pi -e 's/x\[(\d)\]/vertices[$1](0)/g;' *3d_inverse_jacobian
 perl -pi -e 's/y\[(\d)\]/vertices[$1](1)/g;' *3d_inverse_jacobian
-perl -pi -e 's/inverseJacobian/jacobians[point]/g;' *3d_inverse_jacobian
+perl -pi -e 's/z\[(\d)\]/vertices[$1](2)/g;' *3d_inverse_jacobian
+perl -pi -e 's/^s*inverseJacobian/              jacobians[point]/g;' *3d_inverse_jacobian
 perl -pi -e 's/\[(\d)\]\[(\d)\] =/($1,$2) =/g;' *3d_inverse_jacobian
 
-perl -pi -e 's/^\s*t/const double t/g;' *3d_inverse_jacobian_grad
+perl -pi -e 's/([^;])\n/$1/g;' *3d_inverse_jacobian_grad
+perl -pi -e 's/^\s*t/              const double t/g;' *3d_inverse_jacobian_grad
 perl -pi -e 's/x\[(\d)\]/vertices[$1](0)/g;' *3d_inverse_jacobian_grad
 perl -pi -e 's/y\[(\d)\]/vertices[$1](1)/g;' *3d_inverse_jacobian_grad
-perl -pi -e 's/inverseJacobian/jacobians_grad[point]/g;' *3d_inverse_jacobian_grad
+perl -pi -e 's/z\[(\d)\]/vertices[$1](2)/g;' *3d_inverse_jacobian_grad
+perl -pi -e 's/^\s*grad_inverseJacobian/              jacobians_grad[point]/g;' *3d_inverse_jacobian_grad
 
 
 perl -pi -e 's/^array.*\n//g; s/^\s*\]\)//g; s/^\n//g;' *3d_unit_support_points
index ce65300c09117b97adbbd24b20a25a6ebc68b619..7415b83f274e178deec478931ccda7c044891a01 100644 (file)
@@ -38,10 +38,11 @@ bool SubCellData::check_consistency (const unsigned int dim) const {
 template <int dim>
 Triangulation<dim>::Triangulation (const MeshSmoothing smooth_grid) :
                Subscriptor (),
+               boundary (0),
                smooth_grid(smooth_grid)
 {
-  static StraightBoundary<dim> default_boundary;
-  boundary = &default_boundary;
+                                  // set default boundary
+  set_boundary (0);
   
   levels.push_back (new TriangulationLevel<dim>);
 };
@@ -63,6 +64,7 @@ Triangulation<dim>::~Triangulation () {
   for (unsigned int i=0; i<levels.size(); ++i)
     delete levels[i];
 
+  boundary->unsubscribe ();
   levels.clear ();
 };
 
@@ -70,7 +72,17 @@ Triangulation<dim>::~Triangulation () {
 
 template <int dim>
 void Triangulation<dim>::set_boundary (const Boundary<dim> *boundary_object) {
-  boundary = boundary_object;
+  static StraightBoundary<dim> default_boundary;
+
+  if (boundary != 0)
+    boundary->unsubscribe ();
+
+  if (boundary_object != 0)
+    boundary = boundary_object;
+  else
+    boundary = &default_boundary;
+
+  boundary->subscribe ();
 };
 
 
@@ -114,6 +126,29 @@ Triangulation<2>::end () const {
 
 #endif
 
+
+
+#if deal_II_dimension == 3
+
+template <>
+TriaDimensionInfo<3>::cell_iterator
+Triangulation<3>::begin (const unsigned int level) const {
+  return begin_hex (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::raw_cell_iterator
+Triangulation<3>::end () const {
+  return end_hex ();
+};
+
+#endif
+
+
+
+
 /*-----------------------------------------------------------------*/
 
 
@@ -127,9 +162,13 @@ void Triangulation<dim>::copy_triangulation (const Triangulation<dim> &old_tria)
                                   // copy normal elements
   vertices      = old_tria.vertices;
   vertices_used = old_tria.vertices_used;
-  boundary      = old_tria.boundary;
   smooth_grid   = old_tria.smooth_grid;
 
+  if (boundary)
+    boundary->unsubscribe ();
+  boundary      = old_tria.boundary;
+  boundary->subscribe ();
+
                                   // delete only level previously existing,
                                   // reserve space for new and copy
   delete levels[0];
@@ -191,7 +230,6 @@ void Triangulation<1>::create_triangulation (const vector<Point<1> >    &v,
     };
 
 
-#ifdef DEBUG
                                   // some security tests
   unsigned int boundary_nodes = 0;
   for (unsigned int i=0; i<lines_at_vertex.size(); ++i)
@@ -203,13 +241,12 @@ void Triangulation<1>::create_triangulation (const vector<Point<1> >    &v,
        case 2:
              break;
        default:     // a node must have one or two adjacent lines
-             Assert (false, ExcInternalError());
+             AssertThrow (false, ExcInternalError());
       };
 
                                   // assert there are no more than two boundary
                                   // nodes
-  Assert (boundary_nodes == 2, ExcInternalError());
-#endif
+  AssertThrow (boundary_nodes == 2, ExcInternalError());
 
 
                                   // update neighborship info
@@ -319,14 +356,10 @@ void Triangulation<2>::create_triangulation (const vector<Point<2> >    &v,
   map<pair<int,int>,line_iterator> needed_lines;
   for (unsigned int cell=0; cell<cells.size(); ++cell)
     {
-#ifdef DEBUG
-                                      // in debug mode: check whether vertex
-                                      // indices are valid ones
       for (unsigned int vertex=0; vertex<4; ++vertex)
-       Assert ((0<=cells[cell].vertices[vertex]) &&
-               (cells[cell].vertices[vertex]<(signed int)vertices.size()),
-               ExcInvalidVertexIndex (cell, cells[cell].vertices[vertex], vertices.size()));
-#endif
+       AssertThrow ((0<=cells[cell].vertices[vertex]) &&
+                    (cells[cell].vertices[vertex]<static_cast<signed int>(vertices.size())),
+                    ExcInvalidVertexIndex (cell, cells[cell].vertices[vertex], vertices.size()));
       
       pair<int,int> line_vertices[4] = {   // note the order of the vertices
            make_pair (cells[cell].vertices[0], cells[cell].vertices[1]),
@@ -396,11 +429,11 @@ void Triangulation<2>::create_triangulation (const vector<Point<2> >    &v,
                                           // direction 1->4, while in
                                           // the second it would be 4->1.
                                           // This will cause the exception.
-         Assert (needed_lines.find(make_pair(line_vertices[line].second,
-                                             line_vertices[line].first))
-                 ==
-                 needed_lines.end(),
-                 ExcGridHasInvalidCell(cell));
+         AssertThrow (needed_lines.find(make_pair(line_vertices[line].second,
+                                                  line_vertices[line].first))
+                      ==
+                      needed_lines.end(),
+                      ExcGridHasInvalidCell(cell));
                  
                                           // insert line, with invalid iterator
                                           // if line already exists, then
@@ -410,8 +443,7 @@ void Triangulation<2>::create_triangulation (const vector<Point<2> >    &v,
     };
   
 
-#ifdef DEBUG
-                                  // in debug mode: check the every vertex has
+                                  // check the every vertex has
                                   // at least two adjacent lines
   if (true) 
     {
@@ -426,11 +458,10 @@ void Triangulation<2>::create_triangulation (const vector<Point<2> >    &v,
 
                                       // assert minimum touch count is at
                                       // least two
-      Assert (* (min_element(vertex_touch_count.begin(),
-                            vertex_touch_count.end())) >= 2,
-             ExcGridHasInvalidVertices());
+      AssertThrow (* (min_element(vertex_touch_count.begin(),
+                                 vertex_touch_count.end())) >= 2,
+                  ExcGridHasInvalidVertices());
     };
-#endif
        
                                   // reserve enough space
   levels[0]->TriangulationLevel<0>::reserve_space (cells.size(), dim);
@@ -446,6 +477,7 @@ void Triangulation<2>::create_triangulation (const vector<Point<2> >    &v,
        {
          line->set (Line(i->first.first, i->first.second));
          line->set_used_flag ();
+         line->clear_user_flag ();
          line->clear_user_pointer ();
          i->second = line;
        };
@@ -501,9 +533,9 @@ void Triangulation<2>::create_triangulation (const vector<Point<2> >    &v,
       const unsigned int n_adj_cells = adjacent_cells[line->index()].size();
                                       // assert that every line has one or
                                       // two adjacent cells
-      Assert ((n_adj_cells >= 1) &&
-             (n_adj_cells <= 2),
-             ExcInternalError());
+      AssertThrow ((n_adj_cells >= 1) &&
+                  (n_adj_cells <= 2),
+                  ExcInternalError());
 
                                       // if only one cell: line is at
                                       // boundary -> give it the boundary
@@ -538,16 +570,16 @@ void Triangulation<2>::create_triangulation (const vector<Point<2> >    &v,
          else 
            {
                                               // line does not exist
-             Assert (false, ExcLineInexistant(line_vertices.first,
-                                              line_vertices.second));
+             AssertThrow (false, ExcLineInexistant(line_vertices.first,
+                                                   line_vertices.second));
              line = end_line();
            };
        };
 
                                       // Assert that only exterior lines
-                                      // are sgiven a boundary indicator
-      Assert (line->boundary_indicator() == 0,
-             ExcInteriorLineCantBeBoundary());
+                                      // are given a boundary indicator
+      AssertThrow (line->boundary_indicator() == 0,
+                  ExcInteriorLineCantBeBoundary());
 
       line->set_boundary_indicator (boundary_line->material_id);
     };
@@ -669,137 +701,791 @@ void Triangulation<2>::create_hyper_ball (const Point<2> &p, const double radius
 #endif
 
 
+#if deal_II_dimension == 3
+
+/**
+ * Invent an object which compares two Quads against each other. This
+ * comparison is needed in order to establish a map of Quads to iterators
+ * in the Triangulation<3>::create_triangulation function.
+ *
+ * Since this comparison is not canonical, we do not include it into the
+ * general Quad class.
+ */
+struct QuadComparator {
+    bool operator () (const Quad &q1, const Quad &q2) {
+                                      // here is room to optimize the
+                                      // repeated equality test of
+                                      // the previous lines, but I don't
+                                      // care at present
+      if ((q1.line(0) < q2.line(0))          ||
+         ((q1.line(0) == q2.line(0)) &&
+          (q1.line(1) <  q2.line(1)))       ||
+         ((q1.line(0) == q2.line(0)) &&
+          (q1.line(1) == q2.line(1)) &&
+          (q1.line(2) <  q2.line(2)))       ||
+         ((q1.line(0) == q2.line(0)) &&
+          (q1.line(1) == q2.line(1)) &&
+          (q1.line(2) == q2.line(2)) &&
+          (q1.line(3) <  q2.line(3))))
+       return true;
+      else
+       return false;
+    };
+};
+
 
-#if deal_II_dimension == 1
 
 template <>
-void Triangulation<1>::distort_random (const double factor,
-                                      const bool   keep_boundary) {
-                                  // this function is mostly equivalent to
-                                  // that for the general dimensional case
-                                  // the only difference being the correction
-                                  // for split faces which is not necessary
-                                  // in 1D
+void Triangulation<3>::create_triangulation (const vector<Point<3> >    &v,
+                                            const vector<CellData<3> > &c,
+                                            const SubCellData          &subcelldata) {
+  const unsigned int dim=3;
+
+  Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
+  Assert (n_lines() == 0, ExcTriangulationNotEmpty());
+  Assert (n_quads() == 0, ExcTriangulationNotEmpty());
+  Assert (n_hexs() == 0, ExcTriangulationNotEmpty());
+                                  // check that no forbidden arrays are used
+  Assert (subcelldata.check_consistency(dim), ExcInternalError());
+
+                                  // copy vertices
+  vertices = v;
+  vertices_used = vector<bool> (v.size(), true);
+
+                                  // copy cells. This is needed since we
+                                  // may need to change entries
+  vector<CellData<3> > cells(c);
+
+                                  ///////////////////////////////////////
+                                  // first set up some collections of data
                                   //
-                                  // if you change something here, don't
-                                  // forget to do so there as well
+                                  // make up a list of the needed lines
+                                  //
+                                  // each line is a pair of vertices. The list
+                                  // is kept sorted and it is guaranteed
+                                  // that each line is inserted only once.
+                                  // While the key of such an entry is the
+                                  // pair of vertices, the thing it points
+                                  // to is an iterator pointing to the line
+                                  // object itself. In the first run, these
+                                  // iterators are all invalid ones, but they
+                                  // are filled afterwards
+                                  // same applies for the quads
+  map<pair<int,int>,line_iterator> needed_lines;
+  for (unsigned int cell=0; cell<cells.size(); ++cell)
+    {
 
-  const unsigned int dim = 1;
-  
-                                  // find the smallest length of the lines
-                                  // adjacent to the vertex
-  vector<double>             minimal_length (vertices.size(), 1e308);
-                                  // also note if a vertex is at
-                                  // the boundary
-  vector<bool>               at_boundary (vertices.size(), false);
+                                      // check whether vertex
+                                      // indices are valid ones
+      for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+       AssertThrow ((0<=cells[cell].vertices[vertex]) &&
+                    (cells[cell].vertices[vertex]<static_cast<signed int>(vertices.size())),
+                    ExcInvalidVertexIndex (cell, cells[cell].vertices[vertex], vertices.size()));
+      
+      pair<int,int> line_vertices[12] = {   // note the order of the vertices
+                                            // front face
+           make_pair (cells[cell].vertices[0], cells[cell].vertices[1]),
+           make_pair (cells[cell].vertices[1], cells[cell].vertices[2]),
+           make_pair (cells[cell].vertices[3], cells[cell].vertices[2]),
+           make_pair (cells[cell].vertices[0], cells[cell].vertices[3]),
+                                            // back face
+           make_pair (cells[cell].vertices[4], cells[cell].vertices[5]),
+           make_pair (cells[cell].vertices[5], cells[cell].vertices[6]),
+           make_pair (cells[cell].vertices[7], cells[cell].vertices[6]),
+           make_pair (cells[cell].vertices[4], cells[cell].vertices[7]),
+                                            // connects of front and back face
+           make_pair (cells[cell].vertices[0], cells[cell].vertices[4]),
+           make_pair (cells[cell].vertices[1], cells[cell].vertices[5]),
+           make_pair (cells[cell].vertices[2], cells[cell].vertices[6]),
+           make_pair (cells[cell].vertices[3], cells[cell].vertices[7])
+      };
+
+                                      // in the 2d code, some tests were performed
+                                      // which may heal a problem with quads that
+                                      // are rotated such that the lines don't
+                                      // fit snuggly any more. I don't know how
+                                      // to do this in 3d also, so I leve it for
+                                      // future student generations.
+                                      //
+                                      // however, check that the line does not
+                                      // exist in the other direction
+      for (unsigned int line=0; line<12; ++line)
+       {
+                                          // assert that the line was not
+                                          // already inserted in reverse
+                                          // order.
+         AssertThrow (needed_lines.find(make_pair(line_vertices[line].second,
+                                                  line_vertices[line].first))
+                      ==
+                      needed_lines.end(),
+                      ExcGridHasInvalidCell(cell));
+                 
+                                          // insert line, with invalid iterator
+                                          // if line already exists, then
+                                          // nothing bad happens here
+         needed_lines[line_vertices[line]] = end_line();
+       };
+    };
   
-  for (active_line_iterator line=begin_active_line();
-       line != end_line(); ++line)
+
+                                  /////////////////////////////////
+                                  // now for some sanity-checks:
+                                  //
+                                  // check the every vertex has
+                                  // at least two adjacent lines
+  if (true) 
     {
-      if (keep_boundary && line->at_boundary())
+      vector<unsigned short int> vertex_touch_count (v.size(), 0);
+      map<pair<int,int>,line_iterator>::iterator i;
+      for (i=needed_lines.begin(); i!=needed_lines.end(); i++) 
        {
-         at_boundary[line->vertex_index(0)] = true;
-         at_boundary[line->vertex_index(1)] = true;
+                                          // touch the vertices of this line
+         ++vertex_touch_count[i->first.first];
+         ++vertex_touch_count[i->first.second];
        };
-      
-      minimal_length[line->vertex_index(0)]
-       = min(line->diameter(), minimal_length[line->vertex_index(0)]);
-      minimal_length[line->vertex_index(1)]
-       = min(line->diameter(), minimal_length[line->vertex_index(1)]);
+
+                                      // assert minimum touch count is at
+                                      // least two
+      AssertThrow (* (min_element(vertex_touch_count.begin(),
+                            vertex_touch_count.end())) >= 2,
+             ExcGridHasInvalidVertices());
     };
 
 
-  const unsigned int n_vertices = vertices.size();
-  Point<dim> shift_vector;
-  
-  for (unsigned int vertex=0; vertex<n_vertices; ++vertex) 
-    {
-                                      // ignore this vertex if we whall keep
-                                      // the boundary and this vertex *is* at
-                                      // the boundary
-      if (keep_boundary && at_boundary[vertex])
-       continue;
-      
-                                      // first compute a random shift vector
-      for (unsigned int d=0; d<dim; ++d)
-       shift_vector(d) = rand()*1.0/RAND_MAX;
+                                  ///////////////////////////////////
+                                  // actually set up data structures
+                                  // for the lines
+                                  // reserve enough space
+  levels[0]->TriangulationLevel<0>::reserve_space (cells.size(), dim);
+  levels[0]->TriangulationLevel<1>::reserve_space (needed_lines.size());
 
-      shift_vector *= factor * minimal_length[vertex] /
-                     sqrt(shift_vector.square());
+                                  // make up lines
+  if (true) 
+    {
+      raw_line_iterator line = begin_raw_line();
+      map<pair<int,int>,line_iterator>::iterator i;
+      for (i = needed_lines.begin(); line!=end_line(); ++line, ++i) 
+       {
+         line->set (Line(i->first.first, i->first.second));
+         line->set_used_flag ();
+         line->clear_user_flag ();
+         line->clear_user_pointer ();
 
-                                      // finally move the vertex
-      vertices[vertex] += shift_vector;
+                                          // now set the iterator for this
+                                          // line
+         i->second = line;
+       };
     };
-};
 
-#endif
 
+                                  ///////////////////////////////////////////
+                                  // make up the quads of this triangulation
+                                  //
+                                  // same thing: the iterators are set
+                                  // to the invalid value at first, we only
+                                  // collect the data now
 
+                                  // note that QuadComparator is a class
+                                  // declared and defined in this file
+  map<Quad,quad_iterator,QuadComparator> needed_quads;
+  for (unsigned int cell=0; cell<cells.size(); ++cell) 
+    {
+                                      // the faces are quads which consist
+                                      // of four numbers denoting the index
+                                      // of the four lines bounding th
+                                      // quad. we can get this index by
+                                      // asking #needed_lines# for an
+                                      // iterator to this line, dereferencing
+                                      // it and thus return an iterator into
+                                      // the #lines# array of the
+                                      // triangulation, which is already set
+                                      // up. we can then ask this iterator
+                                      // for its index within the present
+                                      // level (the level is zero, of course)
+                                      //
+                                      // to make things easier, we don't
+                                      // creare the lines (pairs of their
+                                      // vertex indices) in place, but before
+                                      // they are really needed. This is just
+                                      // copied from above.
+      pair<int,int> line_list[12] = {   // note the order of the vertices
+                                            // front face
+           make_pair (cells[cell].vertices[0], cells[cell].vertices[1]),
+           make_pair (cells[cell].vertices[1], cells[cell].vertices[2]),
+           make_pair (cells[cell].vertices[3], cells[cell].vertices[2]),
+           make_pair (cells[cell].vertices[0], cells[cell].vertices[3]),
+                                            // back face
+           make_pair (cells[cell].vertices[4], cells[cell].vertices[5]),
+           make_pair (cells[cell].vertices[5], cells[cell].vertices[6]),
+           make_pair (cells[cell].vertices[7], cells[cell].vertices[6]),
+           make_pair (cells[cell].vertices[4], cells[cell].vertices[7]),
+                                            // connects of front and back face
+           make_pair (cells[cell].vertices[0], cells[cell].vertices[4]),
+           make_pair (cells[cell].vertices[1], cells[cell].vertices[5]),
+           make_pair (cells[cell].vertices[2], cells[cell].vertices[6]),
+           make_pair (cells[cell].vertices[3], cells[cell].vertices[7])
+      };
 
-template <int dim>
-void Triangulation<dim>::distort_random (const double factor,
-                                        const bool   keep_boundary) {
-                                  // this function is mostly equivalent to
-                                  // that for the general dimensional case
-                                  // the only difference being the correction
-                                  // for split faces which is not necessary
-                                  // in 1D
-                                  //
-                                  // if you change something here, don't
-                                  // forget to do so there as well
-  
-                                  // find the smallest length of the lines
-                                  // adjecent to the vertex
-  vector<double>             minimal_length (vertices.size(), 1e308);
-                                  // also note if a vertex is at
-                                  // the boundary
-  vector<bool>               at_boundary (vertices.size(), false);
+      Quad faces[6]
+       = {
+                                              // front face
+             Quad (needed_lines[line_list[0]]->index(),
+                   needed_lines[line_list[1]]->index(),
+                   needed_lines[line_list[2]]->index(),
+                   needed_lines[line_list[3]]->index()),
+                                              // back face
+             Quad (needed_lines[line_list[4]]->index(),
+                   needed_lines[line_list[5]]->index(),
+                   needed_lines[line_list[6]]->index(),
+                   needed_lines[line_list[7]]->index()),
+                                              // bottom face
+             Quad (needed_lines[line_list[0]]->index(),
+                   needed_lines[line_list[9]]->index(),
+                   needed_lines[line_list[4]]->index(),
+                   needed_lines[line_list[8]]->index()),
+                                              // right face
+             Quad (needed_lines[line_list[9]]->index(),
+                   needed_lines[line_list[5]]->index(),
+                   needed_lines[line_list[10]]->index(),
+                   needed_lines[line_list[1]]->index()),
+                                              // top face
+             Quad (needed_lines[line_list[2]]->index(),
+                   needed_lines[line_list[10]]->index(),
+                   needed_lines[line_list[6]]->index(),
+                   needed_lines[line_list[11]]->index()),
+                                              // left face
+             Quad (needed_lines[line_list[8]]->index(),
+                   needed_lines[line_list[7]]->index(),
+                   needed_lines[line_list[11]]->index(),
+                   needed_lines[line_list[3]]->index())    };
+
+                                      // in the 2d code, some tests were performed
+                                      // which may heal a problem with hexes that
+                                      // are rotated such that the quads don't
+                                      // fit snuggly any more. I don't know how
+                                      // to do this in here, so I leve it for
+                                      // future student generations.
+      for (unsigned int quad=0; quad<6; ++quad)
+                                        // insert quad, with invalid iterator
+                                        // if quad already exists, then
+                                        // nothing bad happens here
+         needed_quads[faces[quad]] = end_quad();
+    };
   
-  for (active_line_iterator line=begin_active_line();
-       line != end_line(); ++line)
+
+                                  /////////////////////////////////
+                                  // enter the resulting quads into
+                                  // the arrays of the Triangulation
+                                  //
+                                  // first reserve enough space
+  levels[0]->TriangulationLevel<2>::reserve_space (needed_quads.size());
+  if (true) 
     {
-      if (keep_boundary && line->at_boundary())
+      raw_quad_iterator quad = begin_raw_quad();
+      map<Quad,quad_iterator>::iterator q;
+      for (q = needed_quads.begin(); quad!=end_quad(); ++quad, ++q)
        {
-         at_boundary[line->vertex_index(0)] = true;
-         at_boundary[line->vertex_index(1)] = true;
+         quad->set (q->first);
+         quad->set_used_flag ();
+         quad->clear_user_flag ();
+         quad->clear_user_pointer ();
+
+                                          // now set the iterator for this
+                                          // quad
+         q->second = quad;
        };
-      
-      minimal_length[line->vertex_index(0)]
-       = min(line->diameter(), minimal_length[line->vertex_index(0)]);
-      minimal_length[line->vertex_index(1)]
-       = min(line->diameter(), minimal_length[line->vertex_index(1)]);
     };
 
+                                  /////////////////////////////////
+                                  // finally create the cells
+  levels[0]->TriangulationLevel<3>::reserve_space (cells.size());  
 
-  const unsigned int n_vertices = vertices.size();
-  Point<dim> shift_vector;
-  
-  for (unsigned int vertex=0; vertex<n_vertices; ++vertex) 
+                                  // store for each quad index
+                                  // the adjacent cells
+  map<int,vector<cell_iterator> > adjacent_cells;
+
+                                  // finally make up cells
+  if (true) 
     {
-                                      // ignore this vertex if we whall keep
-                                      // the boundary and this vertex *is* at
-                                      // the boundary
-      if (keep_boundary && at_boundary[vertex])
-       continue;
-      
-                                      // first compute a random shift vector
-      for (unsigned int d=0; d<dim; ++d)
-       shift_vector(d) = rand()*1.0/RAND_MAX;
+      raw_cell_iterator cell = begin_raw_hex();
+      for (unsigned int c=0; c<cells.size(); ++c, ++cell)
+       {
+                                          // first find for each of the
+                                          // cells the quad iterator of
+                                          // the respective faces.
+                                          //
+                                          // to this end, set up the
+                                          // lines of this cell and find
+                                          // the quads that are bounded by
+                                          // these lines; these are then
+                                          // the faces of the present cell
+         pair<int,int> line_list[12] = {   // note the order of the vertices
+                                                // front face
+               make_pair (cells[c].vertices[0], cells[c].vertices[1]),
+               make_pair (cells[c].vertices[1], cells[c].vertices[2]),
+               make_pair (cells[c].vertices[3], cells[c].vertices[2]),
+               make_pair (cells[c].vertices[0], cells[c].vertices[3]),
+                                                // back face
+               make_pair (cells[c].vertices[4], cells[c].vertices[5]),
+               make_pair (cells[c].vertices[5], cells[c].vertices[6]),
+               make_pair (cells[c].vertices[7], cells[c].vertices[6]),
+               make_pair (cells[c].vertices[4], cells[c].vertices[7]),
+                                                // connects of front and back face
+               make_pair (cells[c].vertices[0], cells[c].vertices[4]),
+               make_pair (cells[c].vertices[1], cells[c].vertices[5]),
+               make_pair (cells[c].vertices[2], cells[c].vertices[6]),
+               make_pair (cells[c].vertices[3], cells[c].vertices[7])
+         };
 
-      shift_vector *= factor * minimal_length[vertex] /
-                     sqrt(shift_vector.square());
+         Quad faces[6]
+           = {
+                                                  // front face
+                 Quad (needed_lines[line_list[0]]->index(),
+                       needed_lines[line_list[1]]->index(),
+                       needed_lines[line_list[2]]->index(),
+                       needed_lines[line_list[3]]->index()),
+                                                  // back face
+                 Quad (needed_lines[line_list[4]]->index(),
+                       needed_lines[line_list[5]]->index(),
+                       needed_lines[line_list[6]]->index(),
+                       needed_lines[line_list[7]]->index()),
+                                                  // bottom face
+                 Quad (needed_lines[line_list[0]]->index(),
+                       needed_lines[line_list[9]]->index(),
+                       needed_lines[line_list[4]]->index(),
+                       needed_lines[line_list[8]]->index()),
+                                                  // right face
+                 Quad (needed_lines[line_list[9]]->index(),
+                       needed_lines[line_list[5]]->index(),
+                       needed_lines[line_list[10]]->index(),
+                       needed_lines[line_list[1]]->index()),
+                                                  // top face
+                 Quad (needed_lines[line_list[2]]->index(),
+                       needed_lines[line_list[10]]->index(),
+                       needed_lines[line_list[6]]->index(),
+                       needed_lines[line_list[11]]->index()),
+                                                  // left face
+                 Quad (needed_lines[line_list[8]]->index(),
+                       needed_lines[line_list[7]]->index(),
+                       needed_lines[line_list[11]]->index(),
+                       needed_lines[line_list[3]]->index())    };
+
+                                          // get the iterators corresponding
+                                          // to the faces
+         const quad_iterator face_iterator[6] = {
+               needed_quads[faces[0]],
+               needed_quads[faces[1]],
+               needed_quads[faces[2]],
+               needed_quads[faces[3]],
+               needed_quads[faces[4]],
+               needed_quads[faces[5]]};
+
+                                          // make the cell out of these
+                                          // iterators
+         cell->set (Hexahedron(face_iterator[0]->index(),
+                               face_iterator[1]->index(),
+                               face_iterator[2]->index(),
+                               face_iterator[3]->index(),
+                               face_iterator[4]->index(),
+                               face_iterator[5]->index()));
+         
+         cell->set_used_flag ();
+         cell->set_material_id (cells[c].material_id);
+         cell->clear_user_flag ();
+         cell->clear_user_pointer ();
+                                          // note that this cell is adjacent
+                                          // to the four lines
+         for (unsigned int quad=0; quad<6; ++quad)
+           adjacent_cells[face_iterator[quad]->index()].push_back (cell);
+         
+                                          // make some checks on the lines
+                                          // and their ordering; if the
+                                          // lines are right, so are the
+                                          // vertices
+         Assert (face_iterator[0]->line(0) == face_iterator[2]->line(0),
+                 ExcInternalErrorOnCell(c));
+         Assert (face_iterator[0]->line(1) == face_iterator[3]->line(3),
+                 ExcInternalErrorOnCell(c));
+         Assert (face_iterator[0]->line(2) == face_iterator[4]->line(0),
+                 ExcInternalErrorOnCell(c));
+         Assert (face_iterator[0]->line(3) == face_iterator[5]->line(3),
+                 ExcInternalErrorOnCell(c));
 
-                                      // finally move the vertex
-      vertices[vertex] += shift_vector;
-    };
+         Assert (face_iterator[1]->line(0) == face_iterator[2]->line(2),
+                 ExcInternalErrorOnCell(c));
+         Assert (face_iterator[1]->line(1) == face_iterator[3]->line(1),
+                 ExcInternalErrorOnCell(c));
+         Assert (face_iterator[1]->line(2) == face_iterator[4]->line(2),
+                 ExcInternalErrorOnCell(c));
+         Assert (face_iterator[1]->line(3) == face_iterator[5]->line(1),
+                 ExcInternalErrorOnCell(c));
 
+         Assert (face_iterator[2]->line(1) == face_iterator[3]->line(0),
+                 ExcInternalErrorOnCell(c));
+         Assert (face_iterator[3]->line(2) == face_iterator[4]->line(1),
+                 ExcInternalErrorOnCell(c));
+         Assert (face_iterator[4]->line(3) == face_iterator[5]->line(2),
+                 ExcInternalErrorOnCell(c));
+         Assert (face_iterator[5]->line(0) == face_iterator[2]->line(3),
+                 ExcInternalErrorOnCell(c));
+       };
+    };
   
-                                  // finally correct hanging nodes
-                                  // again. The following is not
-                                  // necessary for 1D
-  active_cell_iterator cell = begin_active(),
-                      endc = end();
-  for (; cell!=endc; ++cell) 
+
+                                  /////////////////////////////////////////
+                                  // find those quads which are at the
+                                  // boundary and mark them appropriately
+  for (quad_iterator quad=begin_quad(); quad!=end_quad(); ++quad)
+    {
+      const unsigned int n_adj_cells = adjacent_cells[quad->index()].size();
+                                      // assert that every quad has one or
+                                      // two adjacent cells
+      AssertThrow ((n_adj_cells >= 1) &&
+                  (n_adj_cells <= 2),
+                  ExcInternalError());
+
+                                      // if only one cell: quad is at
+                                      // boundary -> give it the boundary
+                                      // indicator zero by default
+      if (n_adj_cells == 1)
+       quad->set_boundary_indicator (0);
+      else
+                                        // interior quad -> 255
+       quad->set_boundary_indicator (255);
+    };
+
+                                  /////////////////////////////////////////
+                                  // next find those lines which are at
+                                  // the boundary and mark all others as
+                                  // interior ones
+                                  //
+                                  // for this: first mark all lines as
+                                  // interior
+  for (line_iterator line=begin_line(); line!=end_line(); ++line)
+    line->set_boundary_indicator (255);
+                                  // next reset all lines bounding boundary
+                                  // quads as on the boundary also
+  for (quad_iterator quad=begin_quad(); quad!=end_quad(); ++quad)
+    if (quad->at_boundary())
+      for (unsigned int l=0; l<4; ++l)
+       quad->line(l)->set_boundary_indicator (0);
+  
+
+                                  ///////////////////////////////////////
+                                  // now set boundary indicators
+                                  // where given
+                                  //
+                                  // not yet implemented
+  AssertThrow ((subcelldata.boundary_lines.size() == 0) &&
+              (subcelldata.boundary_quads.size() == 0),
+              ExcInternalError());
+  
+
+                                  /////////////////////////////////////////
+                                  // finally update neighborship info
+  for (cell_iterator cell=begin(); cell!=end(); ++cell)
+    for (unsigned int face=0; face<6; ++face)
+      if (adjacent_cells[cell->quad(face)->index()][0] == cell)
+                                        // first adjacent cell is this one
+       {
+         if (adjacent_cells[cell->quad(face)->index()].size() == 2)
+                                            // there is another adjacent cell
+           cell->set_neighbor (face,
+                               adjacent_cells[cell->quad(face)->index()][1]);
+       }
+                                  // first adjacent cell is not this one,
+                                  // -> it must be the neighbor we are
+                                  // looking for
+      else
+       cell->set_neighbor (face,
+                           adjacent_cells[cell->quad(face)->index()][0]);
+};
+
+
+
+template <>
+void Triangulation<3>::create_hypercube (const double left,
+                                        const double right) {
+  Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
+  Assert (n_lines() == 0, ExcTriangulationNotEmpty());
+  Assert (n_quads() == 0, ExcTriangulationNotEmpty());
+  Assert (n_hexs() == 0, ExcTriangulationNotEmpty());
+
+  const Point<3> vertices[8] = { Point<3>(left,left,left),
+                                Point<3>(right,left,left),
+                                Point<3>(right,right,left),
+                                Point<3>(left,right,left),
+                                Point<3>(left,left,right),
+                                Point<3>(right,left,right),
+                                Point<3>(right,right,right),
+                                Point<3>(left,right,right)};
+  const int cell_vertices[1][8] = { { 0,1,2,3,4,5,6,7 } };
+  vector<CellData<3> > cells (1, CellData<3>());
+  for (unsigned int j=0; j<8; ++j)
+    cells[0].vertices[j] = cell_vertices[0][j];
+  cells[0].material_id = 0;
+  
+  create_triangulation (vector<Point<3> >(&vertices[0], &vertices[8]),
+                       cells,
+                       SubCellData());       // no boundary information
+};
+
+
+
+template <>
+void Triangulation<3>::create_hyper_L (const double a, const double b) {
+  const unsigned int dim=3;
+                                  // we slice out the top back right
+                                  // part of the cube
+  const Point<dim> vertices[26]
+    = {
+                                          // front face of the big cube
+         Point<dim> (a,      a,a),
+         Point<dim> ((a+b)/2,a,a),
+         Point<dim> (b,      a,a),
+         Point<dim> (a,      a,(a+b)/2),
+         Point<dim> ((a+b)/2,a,(a+b)/2),
+         Point<dim> (b,      a,(a+b)/2),
+         Point<dim> (a,      a,b),
+         Point<dim> ((a+b)/2,a,b),
+         Point<dim> (b,      a,b),
+                                          // middle face of the big cube
+         Point<dim> (a,      (a+b)/2,a),
+         Point<dim> ((a+b)/2,(a+b)/2,a),
+         Point<dim> (b,      (a+b)/2,a),
+         Point<dim> (a,      (a+b)/2,(a+b)/2),
+         Point<dim> ((a+b)/2,(a+b)/2,(a+b)/2),
+         Point<dim> (b,      (a+b)/2,(a+b)/2),
+         Point<dim> (a,      (a+b)/2,b),
+         Point<dim> ((a+b)/2,(a+b)/2,b),
+         Point<dim> (b,      (a+b)/2,b),
+                                          // back face of the big cube
+                                          // last (top right) point is missing
+         Point<dim> (a,      b,a),
+         Point<dim> ((a+b)/2,b,a),
+         Point<dim> (b,      b,a),
+         Point<dim> (a,      b,(a+b)/2),
+         Point<dim> ((a+b)/2,b,(a+b)/2),
+         Point<dim> (b,      b,(a+b)/2),
+         Point<dim> (a,      b,b),
+         Point<dim> ((a+b)/2,b,b)
+    };
+  const int cell_vertices[7][8] = {{0, 1, 4, 3, 9, 10, 13, 12},
+                                  {1, 2, 5, 4, 10, 11, 14, 13},
+                                  {3, 4, 7, 6, 12, 13, 16, 15},
+                                  {4, 5, 8, 7, 13, 14, 17, 16},
+                                  {9, 10, 13, 12, 18, 19, 22, 21},
+                                  {10, 11, 14, 13, 19, 20, 23, 22},
+                                  {12, 13, 16, 15, 21, 22, 25, 24}};
+
+  vector<CellData<3> > cells (7, CellData<3>());
+  
+  for (unsigned int i=0; i<7; ++i) 
+    {
+      for (unsigned int j=0; j<8; ++j)
+       cells[i].vertices[j] = cell_vertices[i][j];
+      cells[i].material_id = 0;
+    };
+  
+  create_triangulation (vector<Point<dim> >(&vertices[0], &vertices[26]),
+                       cells,
+                       SubCellData());       // no boundary information
+};
+
+
+
+template <>
+void Triangulation<3>::create_hyper_ball (const Point<3> &p, const double radius) {
+  const double a = 1./(1+sqrt(3)); // equilibrate cell sizes at transition
+                                  // from the inner part to the radial
+                                  // cells
+  const unsigned int n_vertices = 16;
+  const Point<3> vertices[n_vertices]
+    = {
+                                          // first the vertices of the inner
+                                          // cell
+         p+Point<3>(-1,-1,-1)*(radius/sqrt(3)*a),
+         p+Point<3>(+1,-1,-1)*(radius/sqrt(3)*a),
+         p+Point<3>(+1,+1,-1)*(radius/sqrt(3)*a),
+         p+Point<3>(-1,+1,-1)*(radius/sqrt(3)*a),
+         p+Point<3>(-1,-1,+1)*(radius/sqrt(3)*a),
+         p+Point<3>(+1,-1,+1)*(radius/sqrt(3)*a),
+         p+Point<3>(+1,+1,+1)*(radius/sqrt(3)*a),
+         p+Point<3>(-1,+1,+1)*(radius/sqrt(3)*a),
+                                          // now the eight vertices at
+                                          // the outer sphere
+         p+Point<3>(-1,-1,-1)*(radius/sqrt(3)),
+         p+Point<3>(+1,-1,-1)*(radius/sqrt(3)),
+         p+Point<3>(+1,+1,-1)*(radius/sqrt(3)),
+         p+Point<3>(-1,+1,-1)*(radius/sqrt(3)),
+         p+Point<3>(-1,-1,+1)*(radius/sqrt(3)),
+         p+Point<3>(+1,-1,+1)*(radius/sqrt(3)),
+         p+Point<3>(+1,+1,+1)*(radius/sqrt(3)),
+         p+Point<3>(-1,+1,+1)*(radius/sqrt(3))
+    };
+
+                                  // one needs to draw the seven cubes to
+                                  // understand what's going on here
+  const unsigned int n_cells = 7;
+  const int cell_vertices[n_cells][8] = {{0, 1, 2, 3, 4, 5, 6, 7},
+                                        {8, 9, 10, 11, 0, 1, 2, 3},
+                                        {9, 13, 14, 10, 1, 5, 6, 2},
+                                        {12, 4, 7, 15, 13, 5, 6, 14},
+                                        {8, 0, 3, 11, 12, 4, 7, 15},
+                                        {11, 10,14, 15, 3, 2, 6, 7},
+                                        {8, 9, 13, 12, 0, 1, 5, 4}};
+
+  vector<CellData<3> > cells (n_cells, CellData<3>());
+  
+  for (unsigned int i=0; i<n_cells; ++i) 
+    {
+      for (unsigned int j=0; j<GeometryInfo<3>::vertices_per_cell; ++j)
+       cells[i].vertices[j] = cell_vertices[i][j];
+      cells[i].material_id = 0;
+    };
+  
+  create_triangulation (vector<Point<3> >(&vertices[0], &vertices[n_vertices]),
+                       cells,
+                       SubCellData());       // no boundary information
+};
+
+
+
+#endif
+
+
+
+
+#if deal_II_dimension == 1
+
+template <>
+void Triangulation<1>::distort_random (const double factor,
+                                      const bool   keep_boundary) {
+                                  // this function is mostly equivalent to
+                                  // that for the general dimensional case
+                                  // the only difference being the correction
+                                  // for split faces which is not necessary
+                                  // in 1D
+                                  //
+                                  // if you change something here, don't
+                                  // forget to do so there as well
+
+  const unsigned int dim = 1;
+  
+                                  // find the smallest length of the lines
+                                  // adjacent to the vertex
+  vector<double>             minimal_length (vertices.size(), 1e308);
+                                  // also note if a vertex is at
+                                  // the boundary
+  vector<bool>               at_boundary (vertices.size(), false);
+  
+  for (active_line_iterator line=begin_active_line();
+       line != end_line(); ++line)
+    {
+      if (keep_boundary && line->at_boundary())
+       {
+         at_boundary[line->vertex_index(0)] = true;
+         at_boundary[line->vertex_index(1)] = true;
+       };
+      
+      minimal_length[line->vertex_index(0)]
+       = min(line->diameter(), minimal_length[line->vertex_index(0)]);
+      minimal_length[line->vertex_index(1)]
+       = min(line->diameter(), minimal_length[line->vertex_index(1)]);
+    };
+
+
+  const unsigned int n_vertices = vertices.size();
+  Point<dim> shift_vector;
+  
+  for (unsigned int vertex=0; vertex<n_vertices; ++vertex) 
+    {
+                                      // ignore this vertex if we whall keep
+                                      // the boundary and this vertex *is* at
+                                      // the boundary
+      if (keep_boundary && at_boundary[vertex])
+       continue;
+      
+                                      // first compute a random shift vector
+      for (unsigned int d=0; d<dim; ++d)
+       shift_vector(d) = rand()*1.0/RAND_MAX;
+
+      shift_vector *= factor * minimal_length[vertex] /
+                     sqrt(shift_vector.square());
+
+                                      // finally move the vertex
+      vertices[vertex] += shift_vector;
+    };
+};
+
+#endif
+
+
+
+template <int dim>
+void Triangulation<dim>::distort_random (const double factor,
+                                        const bool   keep_boundary) {
+                                  // this function is mostly equivalent to
+                                  // that for the general dimensional case
+                                  // the only difference being the correction
+                                  // for split faces which is not necessary
+                                  // in 1D
+                                  //
+                                  // if you change something here, don't
+                                  // forget to do so there as well
+  
+                                  // find the smallest length of the lines
+                                  // adjecent to the vertex
+  vector<double>             minimal_length (vertices.size(), 1e308);
+                                  // also note if a vertex is at
+                                  // the boundary
+  vector<bool>               at_boundary (vertices.size(), false);
+  
+  for (active_line_iterator line=begin_active_line();
+       line != end_line(); ++line)
+    {
+      if (keep_boundary && line->at_boundary())
+       {
+         at_boundary[line->vertex_index(0)] = true;
+         at_boundary[line->vertex_index(1)] = true;
+       };
+      
+      minimal_length[line->vertex_index(0)]
+       = min(line->diameter(), minimal_length[line->vertex_index(0)]);
+      minimal_length[line->vertex_index(1)]
+       = min(line->diameter(), minimal_length[line->vertex_index(1)]);
+    };
+
+
+  const unsigned int n_vertices = vertices.size();
+  Point<dim> shift_vector;
+  
+  for (unsigned int vertex=0; vertex<n_vertices; ++vertex) 
+    {
+                                      // ignore this vertex if we whall keep
+                                      // the boundary and this vertex *is* at
+                                      // the boundary
+      if (keep_boundary && at_boundary[vertex])
+       continue;
+      
+                                      // first compute a random shift vector
+      for (unsigned int d=0; d<dim; ++d)
+       shift_vector(d) = rand()*1.0/RAND_MAX;
+
+      shift_vector *= factor * minimal_length[vertex] /
+                     sqrt(shift_vector.square());
+
+                                      // finally move the vertex
+      vertices[vertex] += shift_vector;
+    };
+
+  
+                                  // finally correct hanging nodes
+                                  // again. The following is not
+                                  // necessary for 1D
+  active_cell_iterator cell = begin_active(),
+                      endc = end();
+  for (; cell!=endc; ++cell) 
     for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
       if (cell->face(face)->has_children() &&
          !cell->face(face)->at_boundary())
@@ -1033,41 +1719,105 @@ void Triangulation<2>::save_user_flags (vector<bool> &v) const {
 
 
 
-template <int dim>
-void Triangulation<dim>::save_user_flags_line (vector<bool> &v) const {
-  v.resize (n_lines(), false);
-  vector<bool>::iterator  i = v.begin();
+
+#if deal_II_dimension == 3
+
+template <>
+void Triangulation<3>::clear_user_pointers () {
   line_iterator line = begin_line(),
                endl = end_line();
-  for (; line!=endl; ++line, ++i)
-    *i = line->user_flag_set();
-};
-
+  for (; line!=endl; ++line)
+    line->clear_user_pointer ();
 
+  quad_iterator quad = begin_quad(),
+               endq = end_quad();
+  for (; quad!=endq; ++quad)
+    quad->clear_user_pointer ();
 
-template <int dim>
-void Triangulation<dim>::save_user_flags_line (ostream &out) const {
-  vector<bool> v;
-  save_user_flags_line (v);
-  write_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
-                    out);
+  cell_iterator cell = begin(),
+               endc = end();
+  for (; cell!=endc; ++cell)
+    cell->clear_user_pointer ();
 };
 
 
 
-template <int dim>
-void Triangulation<dim>::load_user_flags_line (istream &in) {
-  vector<bool> v;
-  read_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
-                   in);
-  load_user_flags_line (v);
+template <>
+void Triangulation<3>::clear_user_flags () {
+  line_iterator line = begin_line(),
+               endl = end_line();
+  for (; line!=endl; ++line)
+    line->clear_user_flag ();
+
+  quad_iterator quad = begin_quad(),
+               endq = end_quad();
+  for (; quad!=endq; ++quad)
+    quad->clear_user_flag ();
+
+  cell_iterator cell = begin(),
+               endc = end();
+  for (; cell!=endc; ++cell)
+    cell->clear_user_flag ();
 };
 
 
 
-template <int dim>
-void Triangulation<dim>::load_user_flags_line (const vector<bool> &v) {
-  Assert (v.size() == n_active_cells(), ExcGridReadError());
+template <>
+void Triangulation<3>::save_user_flags (ostream &out) const {
+  save_user_flags_line (out);
+  save_user_flags_quad (out);
+  save_user_flags_hex (out);
+};
+
+
+
+template <>
+void Triangulation<3>::save_user_flags (vector<bool> &v) const {
+  save_user_flags_line (v);
+  save_user_flags_quad (v);
+  save_user_flags_hex (v);
+};
+
+
+#endif
+
+
+
+template <int dim>
+void Triangulation<dim>::save_user_flags_line (vector<bool> &v) const {
+  v.resize (n_lines(), false);
+  vector<bool>::iterator  i = v.begin();
+  line_iterator line = begin_line(),
+               endl = end_line();
+  for (; line!=endl; ++line, ++i)
+    *i = line->user_flag_set();
+};
+
+
+
+template <int dim>
+void Triangulation<dim>::save_user_flags_line (ostream &out) const {
+  vector<bool> v;
+  save_user_flags_line (v);
+  write_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
+                    out);
+};
+
+
+
+template <int dim>
+void Triangulation<dim>::load_user_flags_line (istream &in) {
+  vector<bool> v;
+  read_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
+                   in);
+  load_user_flags_line (v);
+};
+
+
+
+template <int dim>
+void Triangulation<dim>::load_user_flags_line (const vector<bool> &v) {
+  Assert (v.size() == n_lines(), ExcGridReadError());
   
   line_iterator line = begin_line(),
                endl = end_line();
@@ -1107,6 +1857,31 @@ void Triangulation<1>::load_user_flags_quad (const vector<bool> &) {
   Assert (false, ExcFunctionNotUseful());
 };
 
+
+template <>
+void Triangulation<1>::save_user_flags_hex (ostream &) const {
+  Assert (false, ExcFunctionNotUseful());
+};
+
+
+
+template <>
+void Triangulation<1>::save_user_flags_hex (vector<bool> &) const {
+  Assert (false, ExcFunctionNotUseful());
+};
+
+
+template <>
+void Triangulation<1>::load_user_flags_hex (istream &) {
+  Assert (false, ExcFunctionNotUseful());
+};
+
+
+template <>
+void Triangulation<1>::load_user_flags_hex (const vector<bool> &) {
+  Assert (false, ExcFunctionNotUseful());
+};
+
 #endif
 
 
@@ -1146,7 +1921,7 @@ void Triangulation<dim>::load_user_flags_quad (istream &in) {
 
 template <int dim>
 void Triangulation<dim>::load_user_flags_quad (const vector<bool> &v) {
-  Assert (v.size() == n_active_cells(), ExcGridReadError());
+  Assert (v.size() == n_quads(), ExcGridReadError());
   
   quad_iterator quad = begin_quad(),
                endq = end_quad();
@@ -1160,6 +1935,85 @@ void Triangulation<dim>::load_user_flags_quad (const vector<bool> &v) {
 
 
 
+#if deal_II_dimension == 2
+
+template <>
+void Triangulation<2>::save_user_flags_hex (ostream &) const {
+  Assert (false, ExcFunctionNotUseful());
+};
+
+
+
+template <>
+void Triangulation<2>::save_user_flags_hex (vector<bool> &) const {
+  Assert (false, ExcFunctionNotUseful());
+};
+
+
+template <>
+void Triangulation<2>::load_user_flags_hex (istream &) {
+  Assert (false, ExcFunctionNotUseful());
+};
+
+
+template <>
+void Triangulation<2>::load_user_flags_hex (const vector<bool> &) {
+  Assert (false, ExcFunctionNotUseful());
+};
+
+
+#endif
+
+
+
+
+template <int dim>
+void Triangulation<dim>::save_user_flags_hex (vector<bool> &v) const {
+  v.resize (n_hexs(), false);
+  vector<bool>::iterator  i = v.begin();
+  hex_iterator hex = begin_hex(),
+             endh = end_hex();
+  for (; hex!=endh; ++hex, ++i)
+    *i = hex->user_flag_set();
+};
+
+
+
+template <int dim>
+void Triangulation<dim>::save_user_flags_hex (ostream &out) const {
+  vector<bool> v;
+  save_user_flags_hex (v);
+  write_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
+                    out);
+};
+
+
+
+template <int dim>
+void Triangulation<dim>::load_user_flags_hex (istream &in) {
+  vector<bool> v;
+  read_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
+                   in);
+  load_user_flags_hex (v);
+};
+
+
+
+template <int dim>
+void Triangulation<dim>::load_user_flags_hex (const vector<bool> &v) {
+  Assert (v.size() == n_hexs(), ExcGridReadError());
+  
+  hex_iterator hex = begin_hex(),
+             endh = end_hex();
+  vector<bool>::const_iterator i = v.begin();
+  for (; hex!=endh; ++hex, ++i)
+    if (*i == true)
+      hex->set_user_flag();
+    else
+      hex->clear_user_flag();
+};
+
+
 
 /*------------------------ Iterator functions ------------------------*/
 
@@ -1407,6 +2261,96 @@ Triangulation<1>::last_active_quad () const {
   return 0;
 };
 
+
+
+template <>
+TriaDimensionInfo<1>::raw_hex_iterator
+Triangulation<1>::begin_raw_hex (unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<1>::hex_iterator
+Triangulation<1>::begin_hex (unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<1>::active_hex_iterator
+Triangulation<1>::begin_active_hex (unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<1>::raw_hex_iterator
+Triangulation<1>::end_hex () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<1>::raw_hex_iterator
+Triangulation<1>::last_raw_hex (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<1>::raw_hex_iterator
+Triangulation<1>::last_raw_hex () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<1>::hex_iterator
+Triangulation<1>::last_hex (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<1>::hex_iterator
+Triangulation<1>::last_hex () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<1>::active_hex_iterator
+Triangulation<1>::last_active_hex (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<1>::active_hex_iterator
+Triangulation<1>::last_active_hex () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
 #endif
 
 
@@ -1560,54 +2504,313 @@ Triangulation<2>::last_active_face (const unsigned int level) const {
   return last_active_line (level);
 };
 
-#endif
 
+template <>
+TriaDimensionInfo<2>::raw_hex_iterator
+Triangulation<2>::begin_raw_hex (unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
 
 
 
-template <int dim>
-typename TriaDimensionInfo<dim>::raw_line_iterator
-Triangulation<dim>::begin_raw_line (unsigned int level) const {
-  Assert (level<levels.size(), ExcInvalidLevel(level));
-  
-  if (levels[level]->lines.lines.size() == 0)
-    return end_line ();
-  
-  return raw_line_iterator (const_cast<Triangulation<dim>*>(this),
-                           level,
-                           0);
+template <>
+TriaDimensionInfo<2>::hex_iterator
+Triangulation<2>::begin_hex (unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
+template <>
+TriaDimensionInfo<2>::active_hex_iterator
+Triangulation<2>::begin_active_hex (unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
 
-template <int dim>
-typename TriaDimensionInfo<dim>::raw_quad_iterator
-Triangulation<dim>::begin_raw_quad (unsigned int level) const {
-  Assert (level<levels.size(), ExcInvalidLevel(level));
 
-  if (levels[level]->quads.quads.size() == 0)
-    return end_quad();
-  
-  return raw_quad_iterator (const_cast<Triangulation<dim>*>(this),
-                           level,
-                           0);
-};
 
+template <>
+TriaDimensionInfo<2>::raw_hex_iterator
+Triangulation<2>::end_hex () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
 
 
 
-template <int dim>
-typename TriaDimensionInfo<dim>::line_iterator
-Triangulation<dim>::begin_line (unsigned int level) const {
-                                  // level is checked in begin_raw
-  raw_line_iterator ri = begin_raw_line (level);
-  if (ri.state() != valid)
-    return ri;
-  while (ri->used() == false)
-    if ((++ri).state() != valid)
-      return ri;
-  return ri;
+template <>
+TriaDimensionInfo<2>::raw_hex_iterator
+Triangulation<2>::last_raw_hex (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::raw_hex_iterator
+Triangulation<2>::last_raw_hex () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::hex_iterator
+Triangulation<2>::last_hex (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::hex_iterator
+Triangulation<2>::last_hex () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::active_hex_iterator
+Triangulation<2>::last_active_hex (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::active_hex_iterator
+Triangulation<2>::last_active_hex () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+#endif
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+TriaDimensionInfo<3>::raw_cell_iterator
+Triangulation<3>::begin_raw (const unsigned int level) const {
+  return begin_raw_hex (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::active_cell_iterator
+Triangulation<3>::begin_active (const unsigned int level) const {
+  return begin_active_hex (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::raw_cell_iterator
+Triangulation<3>::last_raw () const {
+  return last_raw_hex ();
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::raw_cell_iterator
+Triangulation<3>::last_raw (const unsigned int level) const {
+  return last_raw_hex (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::cell_iterator
+Triangulation<3>::last () const {
+  return last_hex ();
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::cell_iterator
+Triangulation<3>::last (const unsigned int level) const {
+  return last_hex (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::active_cell_iterator
+Triangulation<3>::last_active () const {
+  return last_active_hex ();
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::active_cell_iterator
+Triangulation<3>::last_active (const unsigned int level) const {
+  return last_active_hex (level);
+};
+
+
+
+
+
+
+
+template <>
+TriaDimensionInfo<3>::raw_face_iterator
+Triangulation<3>::begin_raw_face (const unsigned int level) const {
+  return begin_raw_quad (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::face_iterator
+Triangulation<3>::begin_face (const unsigned int level) const {
+  return begin_quad (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::active_face_iterator
+Triangulation<3>::begin_active_face (const unsigned int level) const {
+  return begin_active_quad (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::raw_face_iterator
+Triangulation<3>::end_face () const {
+  return end_quad ();
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::raw_face_iterator
+Triangulation<3>::last_raw_face () const {
+  return last_raw_quad ();
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::raw_face_iterator
+Triangulation<3>::last_raw_face (const unsigned int level) const {
+  return last_raw_quad (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::face_iterator
+Triangulation<3>::last_face () const {
+  return last_quad ();
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::face_iterator
+Triangulation<3>::last_face (const unsigned int level) const {
+  return last_quad (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::active_face_iterator
+Triangulation<3>::last_active_face () const {
+  return last_active_quad ();
+};
+
+
+
+template <>
+TriaDimensionInfo<3>::active_face_iterator
+Triangulation<3>::last_active_face (const unsigned int level) const {
+  return last_active_quad (level);
+};
+
+
+
+#endif
+
+
+
+
+template <int dim>
+typename TriaDimensionInfo<dim>::raw_line_iterator
+Triangulation<dim>::begin_raw_line (unsigned int level) const {
+  Assert (level<levels.size(), ExcInvalidLevel(level));
+  
+  if (levels[level]->lines.lines.size() == 0)
+    return end_line ();
+  
+  return raw_line_iterator (const_cast<Triangulation<dim>*>(this),
+                           level,
+                           0);
+};
+
+
+
+
+template <int dim>
+typename TriaDimensionInfo<dim>::raw_quad_iterator
+Triangulation<dim>::begin_raw_quad (unsigned int level) const {
+  Assert (level<levels.size(), ExcInvalidLevel(level));
+
+  if (levels[level]->quads.quads.size() == 0)
+    return end_quad();
+  
+  return raw_quad_iterator (const_cast<Triangulation<dim>*>(this),
+                           level,
+                           0);
+};
+
+
+
+template <int dim>
+typename TriaDimensionInfo<dim>::raw_hex_iterator
+Triangulation<dim>::begin_raw_hex (unsigned int level) const {
+  Assert (level<levels.size(), ExcInvalidLevel(level));
+
+  if (levels[level]->hexes.hexes.size() == 0)
+    return end_hex();
+  
+  return raw_hex_iterator (const_cast<Triangulation<dim>*>(this),
+                          level,
+                          0);
+};
+
+
+
+
+template <int dim>
+typename TriaDimensionInfo<dim>::line_iterator
+Triangulation<dim>::begin_line (unsigned int level) const {
+                                  // level is checked in begin_raw
+  raw_line_iterator ri = begin_raw_line (level);
+  if (ri.state() != valid)
+    return ri;
+  while (ri->used() == false)
+    if ((++ri).state() != valid)
+      return ri;
+  return ri;
 };
 
 
@@ -1628,6 +2831,21 @@ Triangulation<dim>::begin_quad (unsigned int level) const {
 
 
 
+template <int dim>
+typename TriaDimensionInfo<dim>::hex_iterator
+Triangulation<dim>::begin_hex (unsigned int level) const {
+                                  // level is checked in begin_raw
+  raw_hex_iterator ri = begin_raw_hex (level);
+  if (ri.state() != valid)
+    return ri;
+  while (ri->used() == false)
+    if ((++ri).state() != valid)
+      return ri;
+  return ri;
+};
+
+
+
 
 template <int dim>
 typename TriaDimensionInfo<dim>::active_line_iterator
@@ -1658,6 +2876,22 @@ Triangulation<dim>::begin_active_quad (unsigned int level) const {
 };
 
 
+
+template <int dim>
+typename TriaDimensionInfo<dim>::active_hex_iterator
+Triangulation<dim>::begin_active_hex (unsigned int level) const {
+                                  // level is checked in begin_raw
+  hex_iterator i = begin_hex (level);
+  if (i.state() != valid)
+    return i;
+  while (i->has_children())
+    if ((++i).state() != valid)
+      return i;
+  return i;
+};
+
+
+
 template <int dim>
 typename TriaDimensionInfo<dim>::raw_line_iterator
 Triangulation<dim>::end_line () const {
@@ -1679,6 +2913,16 @@ Triangulation<dim>::end_quad () const {
 
 
 
+template <int dim>
+typename TriaDimensionInfo<dim>::raw_hex_iterator
+Triangulation<dim>::end_hex () const {
+  return raw_hex_iterator (const_cast<Triangulation<dim>*>(this),
+                          -1,
+                          -1);
+};
+
+
+
 template <int dim>
 typename TriaDimensionInfo<dim>::raw_line_iterator
 Triangulation<dim>::last_raw_line (const unsigned int level) const {
@@ -1693,8 +2937,6 @@ Triangulation<dim>::last_raw_line (const unsigned int level) const {
 
 
 
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::raw_quad_iterator
 Triangulation<dim>::last_raw_quad (const unsigned int level) const {
@@ -1710,6 +2952,21 @@ Triangulation<dim>::last_raw_quad (const unsigned int level) const {
 
 
 
+template <int dim>
+typename TriaDimensionInfo<dim>::raw_hex_iterator
+Triangulation<dim>::last_raw_hex (const unsigned int level) const {
+  Assert (level<levels.size(),
+         ExcInvalidLevel(level));
+  Assert (levels[level]->hexes.hexes.size() != 0,
+         ExcEmptyLevel (level));
+
+  return raw_hex_iterator (const_cast<Triangulation<dim>*>(this),
+                          level,
+                          levels[level]->hexes.hexes.size()-1);
+};
+
+
+
 template <int dim>
 typename TriaDimensionInfo<dim>::raw_line_iterator
 Triangulation<dim>::last_raw_line () const {
@@ -1727,6 +2984,14 @@ Triangulation<dim>::last_raw_quad () const {
 
 
 
+template <int dim>
+typename TriaDimensionInfo<dim>::raw_hex_iterator
+Triangulation<dim>::last_raw_hex () const {
+  return last_raw_hex (levels.size()-1);
+};
+
+
+
 template <int dim>
 typename TriaDimensionInfo<dim>::line_iterator
 Triangulation<dim>::last_line (const unsigned int level) const {
@@ -1742,7 +3007,6 @@ Triangulation<dim>::last_line (const unsigned int level) const {
 
 
 
-
 template <int dim>
 typename TriaDimensionInfo<dim>::quad_iterator
 Triangulation<dim>::last_quad (const unsigned int level) const {
@@ -1759,9 +3023,24 @@ Triangulation<dim>::last_quad (const unsigned int level) const {
 
 
 template <int dim>
-typename TriaDimensionInfo<dim>::line_iterator
-Triangulation<dim>::last_line () const {
-  return last_line (levels.size()-1);
+typename TriaDimensionInfo<dim>::hex_iterator
+Triangulation<dim>::last_hex (const unsigned int level) const {
+                                  // level is checked in begin_raw
+  raw_hex_iterator ri = last_raw_hex(level);
+  if (ri->used()==true)
+    return ri;
+  while ((--ri).state() == valid)
+    if (ri->used()==true)
+      return ri;
+  return ri;
+};
+
+
+
+template <int dim>
+typename TriaDimensionInfo<dim>::line_iterator
+Triangulation<dim>::last_line () const {
+  return last_line (levels.size()-1);
 };
 
 
@@ -1774,6 +3053,14 @@ Triangulation<dim>::last_quad () const {
 
 
 
+template <int dim>
+typename TriaDimensionInfo<dim>::hex_iterator
+Triangulation<dim>::last_hex () const {
+  return last_hex (levels.size()-1);
+};
+
+
+
 
 template <int dim>
 typename TriaDimensionInfo<dim>::active_line_iterator
@@ -1805,6 +3092,21 @@ Triangulation<dim>::last_active_quad (const unsigned int level) const {
 
 
 
+template <int dim>
+typename TriaDimensionInfo<dim>::active_hex_iterator
+Triangulation<dim>::last_active_hex (const unsigned int level) const {
+                                  // level is checked in begin_raw
+  hex_iterator i = last_hex(level);
+  if (i->has_children()==false)
+    return i;
+  while ((--i).state() == valid)
+    if (i->has_children()==false)
+      return i;
+  return i;
+};
+
+
+
 
 template <int dim>
 typename TriaDimensionInfo<dim>::active_line_iterator
@@ -1823,6 +3125,14 @@ Triangulation<dim>::last_active_quad () const {
 
 
 
+template <int dim>
+typename TriaDimensionInfo<dim>::active_hex_iterator
+Triangulation<dim>::last_active_hex () const {
+  return last_active_hex (levels.size()-1);
+};
+
+
+
 
 template <int dim>
 typename TriaDimensionInfo<dim>::raw_cell_iterator
@@ -1947,6 +3257,36 @@ Triangulation<dim>::end_active_quad (const unsigned int level) const {
 
 
 
+template <int dim>
+typename TriaDimensionInfo<dim>::raw_hex_iterator
+Triangulation<dim>::end_raw_hex (const unsigned int level) const {
+  return (level == levels.size()-1 ?
+         end_hex() :
+         begin_raw_hex (level+1));
+};
+
+
+
+template <int dim>
+typename TriaDimensionInfo<dim>::hex_iterator
+Triangulation<dim>::end_hex (const unsigned int level) const {
+  return (level == levels.size()-1 ?
+         hex_iterator(end_hex()) :
+         begin_hex (level+1));
+};
+
+
+
+template <int dim>
+typename TriaDimensionInfo<dim>::active_hex_iterator
+Triangulation<dim>::end_active_hex (const unsigned int level) const {
+  return (level == levels.size()-1 ?
+         active_hex_iterator(end_hex()) :
+         begin_active_hex (level+1));
+};
+
+
+
 
 
 template <int dim>
@@ -2004,6 +3344,24 @@ unsigned int Triangulation<2>::n_active_cells (const unsigned int level) const {
 
 
 
+#if deal_II_dimension == 3
+
+template <>
+unsigned int Triangulation<3>::n_cells (const unsigned int level) const {
+  return n_hexs (level);
+};
+
+
+
+template <>
+unsigned int Triangulation<3>::n_active_cells (const unsigned int level) const {
+  return n_active_hexs (level);
+};
+
+#endif
+
+
+
 
 template <int dim>
 unsigned int Triangulation<dim>::n_lines () const {
@@ -2063,16 +3421,6 @@ unsigned int Triangulation<dim>::n_active_lines (const unsigned int level) const
 
 
 
-template <int dim>
-unsigned int Triangulation<dim>::n_quads () const {
-  unsigned int n=0;
-  for (unsigned int l=0; l<levels.size(); ++l)
-    n += n_quads (l);
-  return n;
-};
-
-
-
 #if deal_II_dimension == 1
 
 template <>
@@ -2093,6 +3441,16 @@ unsigned int Triangulation<1>::n_active_quads (const unsigned int) const {
 #endif
 
 
+template <int dim>
+unsigned int Triangulation<dim>::n_quads () const {
+  unsigned int n=0;
+  for (unsigned int l=0; l<levels.size(); ++l)
+    n += n_quads (l);
+  return n;
+};
+
+
+
 template <int dim>
 unsigned int Triangulation<dim>::n_quads (const unsigned int level) const {
   if (levels[level]->quads.quads.size() == 0)
@@ -2103,7 +3461,7 @@ unsigned int Triangulation<dim>::n_quads (const unsigned int level) const {
   quad_iterator quad = begin_quad (level),
                endc = (level == levels.size()-1 ?
                        quad_iterator(end_quad()) :
-                       begin (level+1));
+                       begin_quad (level+1));
   unsigned int n=0;
   for (; quad!=endc; ++quad)
     ++n;
@@ -2141,6 +3499,101 @@ unsigned int Triangulation<dim>::n_active_quads (const unsigned int level) const
 
 
 
+#if deal_II_dimension < 3
+
+template <>
+unsigned int Triangulation<1>::n_hexs (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+unsigned int Triangulation<1>::n_active_hexs (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+unsigned int Triangulation<2>::n_hexs (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+
+template <>
+unsigned int Triangulation<2>::n_active_hexs (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+#endif
+
+
+
+
+template <int dim>
+unsigned int Triangulation<dim>::n_hexs () const {
+  unsigned int n=0;
+  for (unsigned int l=0; l<levels.size(); ++l)
+    n += n_hexs (l);
+  return n;
+};
+
+
+
+template <int dim>
+unsigned int Triangulation<dim>::n_hexs (const unsigned int level) const {
+  if (levels[level]->hexes.hexes.size() == 0)
+    return 0;
+
+                                  // only evaluate begin_/end_hex if there
+                                  // are hexs.
+  hex_iterator hex = begin_hex (level),
+             endc = (level == levels.size()-1 ?
+                     hex_iterator(end_hex()) :
+                     begin_hex (level+1));
+  unsigned int n=0;
+  for (; hex!=endc; ++hex)
+    ++n;
+  return n;
+};
+
+
+
+template <int dim>
+unsigned int Triangulation<dim>::n_active_hexs () const {
+  unsigned int n=0;
+  for (unsigned int l=0; l<levels.size(); ++l)
+    n += n_active_hexs (l);
+  return n;
+};
+
+
+
+template <int dim>
+unsigned int Triangulation<dim>::n_active_hexs (const unsigned int level) const {
+  if (levels[level]->hexes.hexes.size() == 0)
+    return 0;
+
+                                  // only evaluate begin_/end_hex if there
+                                  // are hexs.
+  active_hex_iterator hex = begin_active_hex (level),
+                    endc = (level == levels.size()-1 ?
+                            active_hex_iterator(end_hex()) :
+                            begin_active_hex (level+1));
+  unsigned int n=0;
+  for (; hex!=endc; ++hex)
+    ++n;
+  return n;
+};
+
+
+
 
 template <int dim>
 unsigned int Triangulation<dim>::n_levels () const {
@@ -2275,6 +3728,49 @@ void Triangulation<2>::print_gnuplot (ostream &out,
 #endif
 
 
+#if deal_II_dimension == 3
+
+template <>
+void Triangulation<3>::print_gnuplot (ostream &out,
+                                     const active_cell_iterator & cell) const {
+  AssertThrow (out, ExcIO());
+
+                                  // front face
+  out << cell->vertex(0) << " " << cell->level() << endl
+      << cell->vertex(1) << " " << cell->level() << endl
+      << cell->vertex(2) << " " << cell->level() << endl
+      << cell->vertex(3) << " " << cell->level() << endl
+      << cell->vertex(0) << " " << cell->level() << endl
+      << endl;
+                                  // back face
+  out << cell->vertex(4) << " " << cell->level() << endl
+      << cell->vertex(5) << " " << cell->level() << endl
+      << cell->vertex(6) << " " << cell->level() << endl
+      << cell->vertex(7) << " " << cell->level() << endl
+      << cell->vertex(4) << " " << cell->level() << endl
+      << endl;
+
+                                  // now for the four connecting lines
+  out << cell->vertex(0) << " " << cell->level() << endl
+      << cell->vertex(4) << " " << cell->level() << endl
+      << endl;
+  out << cell->vertex(1) << " " << cell->level() << endl
+      << cell->vertex(5) << " " << cell->level() << endl
+      << endl;
+  out << cell->vertex(2) << " " << cell->level() << endl
+      << cell->vertex(6) << " " << cell->level() << endl
+      << endl;
+  out << cell->vertex(3) << " " << cell->level() << endl
+      << cell->vertex(7) << " " << cell->level() << endl
+      << endl;
+
+  AssertThrow (out, ExcIO());
+};
+
+#endif
+
+
+
 
 template <int dim>
 void Triangulation<dim>::refine (const dVector &criteria,
@@ -2712,9 +4208,9 @@ void Triangulation<2>::execute_refinement () {
            
                                             // for all neighbors of
                                             // this cell
-           for (unsigned int nb=0; nb<4; ++nb) 
+           for (unsigned int nb=0; nb<GeometryInfo<dim>::faces_per_cell; ++nb) 
              {
-               cell_iterator neighbor = acell->neighbor(nb);
+               const cell_iterator neighbor = acell->neighbor(nb);
                                                 // if cell is at boundary
                if (neighbor.state() != valid) 
                  {
@@ -2799,7 +4295,7 @@ void Triangulation<2>::execute_refinement () {
       levels[level+1]->
        TriangulationLevel<1>::reserve_space (needed_lines);
                                       // reserve space for 4*flagged_cells
-                                      // new lines on the next higher
+                                      // new quads on the next higher
                                       // level
       levels[level+1]->
        TriangulationLevel<2>::reserve_space (4*flagged_cells);
@@ -3222,30 +4718,1235 @@ void Triangulation<2>::execute_refinement () {
            subcells[0]->set_neighbor (2, subcells[3]);
            subcells[0]->set_neighbor (3, neighbors[7]);
 
-           subcells[1]->set_neighbor (0, neighbors[1]);
-           subcells[1]->set_neighbor (1, neighbors[2]);
-           subcells[1]->set_neighbor (2, subcells[2]);
-           subcells[1]->set_neighbor (3, subcells[0]);
+           subcells[1]->set_neighbor (0, neighbors[1]);
+           subcells[1]->set_neighbor (1, neighbors[2]);
+           subcells[1]->set_neighbor (2, subcells[2]);
+           subcells[1]->set_neighbor (3, subcells[0]);
+
+           subcells[2]->set_neighbor (0, subcells[1]);
+           subcells[2]->set_neighbor (1, neighbors[3]);
+           subcells[2]->set_neighbor (2, neighbors[4]);
+           subcells[2]->set_neighbor (3, subcells[3]);
+
+           subcells[3]->set_neighbor (0, subcells[0]);
+           subcells[3]->set_neighbor (1, subcells[2]);
+           subcells[3]->set_neighbor (2, neighbors[5]);
+           subcells[3]->set_neighbor (3, neighbors[6]);
+
+           subcells[0]->set_material_id (cell->material_id());
+           subcells[1]->set_material_id (cell->material_id());
+           subcells[2]->set_material_id (cell->material_id());
+           subcells[3]->set_material_id (cell->material_id());
+         };
+    };
+#ifdef DEBUG
+  for (unsigned int level=0; level<levels.size(); ++level) 
+    levels[level]->monitor_memory (2);
+
+                                  // check whether really all refinement flags
+                                  // are reset (also of previously non-active
+                                  // cells which we may not have touched. If
+                                  // the refinement flag of a non-active cell
+                                  // is set, something went wrong since the
+                                  // cell-accessors should have caught this)
+  cell_iterator cell = begin(),
+               endc = end();
+  while (cell != endc)
+    Assert (!(cell++)->refine_flag_set(), ExcInternalError ());
+#endif
+};
+
+#endif
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+void Triangulation<3>::execute_refinement () {
+  const unsigned int dim = 3;
+
+                                  // do some grid smoothing
+  prepare_refinement ();
+  
+                                  // check whether a new level is needed
+                                  // we have to check for this on the
+                                  // highest level only (on this, all
+                                  // used cells are also active, so we
+                                  // only have to check for this)
+  if (true)
+    {
+      raw_cell_iterator cell = begin_active (levels.size()-1),
+                       endc = end();
+      for (; cell != endc; ++cell)
+       if (cell->used())
+         if (cell->refine_flag_set()) 
+           {
+             levels.push_back (new TriangulationLevel<dim>);
+             break;
+           };
+    };
+
+
+                                  // first clear user flags for
+                                  // quads and lines; we're gonna
+                                  // use them to flag which lines
+                                  // and quads need refinement
+  for (line_iterator line=begin_line(); line!=end_line(); ++line)
+    line->clear_user_flag();
+  for (quad_iterator quad=begin_quad(); quad!=end_quad(); ++quad)
+    quad->clear_user_flag();
+  
+
+
+                                  // check how much space is needed
+                                  // on every level
+                                  // we need not check the highest
+                                  // level since either
+                                  // - on the highest level no cells
+                                  //   are flagged for refinement
+                                  // - there are, but prepare_refinement
+                                  //   added another empty level which
+                                  //   then is the highest level
+  unsigned int needed_vertices = 0;
+  for (int level=levels.size()-2; level>=0; --level)
+    {
+                                      // count number of flagged cells on
+                                      // this level and compute how many
+                                      // new vertices and new lines will
+                                      // be needed
+      unsigned int flagged_cells = 0;
+      unsigned int needed_lines  = 0;
+      unsigned int needed_quads  = 0;
+      
+      active_cell_iterator acell = begin_active(level),
+                          aendc = begin_active(level+1);
+      for (; acell!=aendc; ++acell) 
+       if (acell->refine_flag_set()) 
+         {
+           ++flagged_cells;
+
+                                            // new vertex at center of cell
+                                            // is needed in any case
+           ++needed_vertices;
+                                            // also the six inner lines
+           needed_lines += 6;
+                                            // and the 12 inner quads
+           needed_quads += 12;
+           
+                                            // mark all faces and lines for
+                                            // refinement; checking locally
+                                            // whether the neighbor would
+                                            // also like to refine them is
+                                            // rather difficult for lines
+                                            // so we only flag them and after
+                                            // visiting all cells, we decide
+                                            // which lines need refinement;
+                                            // same for the quads
+           for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell;
+                ++face)
+             {
+               face_iterator aface = acell->face(face);
+               
+               if (aface->has_children() == false) 
+                 {
+                   aface->set_user_flag ();
+                   for (unsigned int line=0; line<4; ++line)
+                     if (aface->line(line)->has_children() == false)
+                       aface->line(line)->set_user_flag ();
+                 };
+             };
+         };
+
+                                      // now count the quads and lines which
+                                      // were flagged for refinement
+      for (quad_iterator quad=begin_quad(); quad!=end_quad(); ++quad)
+       if (quad->user_flag_set())
+         {
+           Assert (quad->has_children() == false, ExcInternalError());
+           needed_quads    += 4;
+           needed_lines    += 4;
+           needed_vertices += 1;
+         };
+
+      for (line_iterator line=begin_line(); line!=end_line(); ++line)
+       if (line->user_flag_set())
+         {
+           Assert (line->has_children() == false, ExcInternalError());
+           needed_lines += 2;
+           needed_vertices += 1;
+         };
+      
+      
+                                      // count number of used cells on
+                                      // the next higher level
+      const unsigned int used_cells
+       = count_if (levels[level+1]->quads.used.begin(),
+               levels[level+1]->quads.used.end(),
+               bind2nd (equal_to<bool>(), true));
+      
+      
+                                      // reserve space for the used_cells
+                                      // cells already existing on the next
+                                      // higher level as well as for the
+                                      // 8*flagged_cells that will be created
+                                      // on that level
+      levels[level+1]->
+       TriangulationLevel<0>::reserve_space (used_cells+8*flagged_cells, 3);
+                                      // reserve space for needed_lines
+                                      // new lines
+      levels[level+1]->
+       TriangulationLevel<1>::reserve_space (needed_lines);
+                                      // reserve space for needed_quads
+                                      // new quads
+      levels[level+1]->
+       TriangulationLevel<2>::reserve_space (needed_quads);
+                                      // reserve space for 8*flagged_cells
+                                      // new hexes on the next higher
+                                      // level
+      levels[level+1]->
+       TriangulationLevel<3>::reserve_space (8*flagged_cells);
+    };
+
+                                  // add to needed vertices how
+                                  // many vertices are already in use
+  needed_vertices += count_if (vertices_used.begin(), vertices_used.end(),
+                              bind2nd (equal_to<bool>(), true));
+                                  // if we need more vertices: create them,
+                                  // if not: leave the array as is, since
+                                  // shrinking is not really possible because
+                                  // some of the vertices at the end may be
+                                  // in use
+  if (needed_vertices > vertices.size())
+    {
+      vertices.resize (needed_vertices, Point<dim>());
+      vertices_used.resize (needed_vertices, false);
+    };
+
+
+                                  ///////////////////////////////////////////
+                                  // Do refinement on every level
+                                  //
+                                  // To make life a bit easier, we first
+                                  // refine those lines and quads that were
+                                  // flagged for refinement and then compose
+                                  // the newly to be created cells.
+                                  //
+                                  //  index of next unused vertex
+  unsigned int next_unused_vertex = 0;
+
+                                  // first for lines
+  for (unsigned int level=0; level!=levels.size()-1; ++level)
+    {
+                                      // only active objects can be refined
+                                      // further; remember that we won't
+                                      // operate on the finest level, so
+                                      // begin_*(level+1) is allowed
+      active_line_iterator line = begin_active_line(level),
+                          endl = begin_active_line(level+1);
+      raw_line_iterator next_unused_line = begin_raw_line (level+1);
+
+      for (; line!=endl; ++line)
+       if (line->user_flag_set())
+         {
+                                            // this line needs to be refined
+
+                                            // find the next unused vertex
+                                            // and set it appropriately
+           while (vertices_used[next_unused_vertex] == true)
+             ++next_unused_vertex;
+           Assert (next_unused_vertex < vertices.size(),
+                   ExcTooFewVerticesAllocated());
+           vertices_used[next_unused_vertex] = true;
+
+           if (line->at_boundary()) 
+             {
+               const Boundary<dim>::PointArray surrounding_points
+                 = { &line->vertex(0),
+                     &line->vertex(0),
+                     &line->vertex(1),
+                     &line->vertex(1) 
+                 };
+               vertices[next_unused_vertex]
+                 = boundary->in_between (surrounding_points);
+             }
+           else
+             vertices[next_unused_vertex]
+               = (line->vertex(0) + line->vertex(1)) / 2;
+         
+                                            // now that we created the right
+                                            // point, make up the two child
+                                            // lines
+                                            // (++ takes care of the end of
+                                            // the vector)
+           while (next_unused_line->used() == true)
+             ++next_unused_line;
+                                            // there should always be two
+                                            // consecutive unused lines, such
+                                            // that the children of a line
+                                            // will be consecutive.
+                                            // then set the child pointer of
+                                            // the present line
+           line->set_children (next_unused_line->index());
+         
+                                            // set the two new lines
+           raw_line_iterator children[2] = { next_unused_line,
+                                             ++next_unused_line };
+                                            // some tests; if any of the
+                                            // iterators should be invalid,
+                                            // then already dereferencing
+                                            // will fail
+           Assert (children[0]->used() == false, ExcCellShouldBeUnused());
+           Assert (children[1]->used() == false, ExcCellShouldBeUnused());
+         
+           children[0]->set (Line(line->vertex_index(0),
+                                  next_unused_vertex));
+           children[1]->set (Line(next_unused_vertex,
+                                  line->vertex_index(1)));
+    
+           children[0]->set_used_flag();
+           children[1]->set_used_flag();
+           children[0]->clear_children();
+           children[1]->clear_children();
+           children[0]->clear_user_pointer();
+           children[1]->clear_user_pointer();
+           children[0]->clear_user_flag();
+           children[1]->clear_user_flag();
+
+           children[0]->set_boundary_indicator (line->boundary_indicator());
+           children[1]->set_boundary_indicator (line->boundary_indicator());
+           
+                                            // finally clear flag indicating
+                                            // the need for refinement
+           line->clear_user_flag ();
+         };
+    };
+
+
+                                  ///////////////////////////////////////
+                                  // now refine marked quads
+  for (unsigned int level=0; level!=levels.size()-1; ++level)
+    {
+                                      // only active objects can be refined
+                                      // further; remember that we won't
+                                      // operate on the finest level, so
+                                      // begin_*(level+1) is allowed
+      active_quad_iterator quad = begin_active_quad(level),
+                          endq = begin_active_quad(level+1);
+      raw_line_iterator next_unused_line = begin_raw_line (level+1);
+      raw_quad_iterator next_unused_quad = begin_raw_quad (level+1);
+
+      for (; quad!=endq; ++quad)
+       if (quad->user_flag_set())
+         {
+                                            // this quad needs to be refined
+
+                                            // find the next unused vertex
+                                            // and set it appropriately
+           while (vertices_used[next_unused_vertex] == true)
+             ++next_unused_vertex;
+           Assert (next_unused_vertex < vertices.size(),
+                   ExcTooFewVerticesAllocated());
+           vertices_used[next_unused_vertex] = true;
+           
+           if (quad->at_boundary()) 
+             {
+               const Boundary<dim>::PointArray surrounding_points
+                 = { &quad->vertex(0),
+                     &quad->vertex(1),
+                     &quad->vertex(2),
+                     &quad->vertex(3) 
+                 };
+               vertices[next_unused_vertex]
+                 = boundary->in_between (surrounding_points);
+             }
+           else
+             vertices[next_unused_vertex]
+               = (quad->vertex(0) + quad->vertex(1) +
+                  quad->vertex(2) + quad->vertex(3)) / 4;
+         
+                                            // now that we created the right
+                                            // point, make up the four
+                                            // lines interior to the quad
+                                            // (++ takes care of the end of
+                                            // the vector)
+           raw_line_iterator new_lines[4];
+
+           for (unsigned int i=0; i<4; ++i)
+             {
+               while (next_unused_line->used() == true)
+                 ++next_unused_line;
+               new_lines[i] = next_unused_line;
+               ++next_unused_line;
+
+               Assert (new_lines[i]->used() == false, ExcCellShouldBeUnused());
+             };
+
+                                            // set the data of the four lines.
+                                            // first collect the indices of
+                                            // the five vertices:
+                                            // *--2--*
+                                            // |  |  |
+                                            // 3--4--1
+                                            // |  |  |
+                                            // *--0--*
+                                            // the lines are numbered as follows:
+                                            // *--*--*
+                                            // |  2  |
+                                            // *3-*-1*
+                                            // |  0  |
+                                            // *--*--*
+           const unsigned int vertex_indices[5]
+             = { quad->line(0)->child(0)->vertex_index(1),
+                 quad->line(1)->child(0)->vertex_index(1),
+                 quad->line(2)->child(0)->vertex_index(1),
+                 quad->line(3)->child(0)->vertex_index(1),
+                 next_unused_vertex 
+             };
+           
+           new_lines[0]->set (Line(vertex_indices[0], vertex_indices[4]));
+           new_lines[1]->set (Line(vertex_indices[4], vertex_indices[1]));
+           new_lines[2]->set (Line(vertex_indices[4], vertex_indices[2]));
+           new_lines[3]->set (Line(vertex_indices[3], vertex_indices[4]));
+
+           for (unsigned int i=0; i<4; ++i)
+             {
+               new_lines[i]->set_used_flag();
+               new_lines[i]->clear_user_flag();
+               new_lines[i]->clear_user_pointer();
+               new_lines[i]->clear_children();
+               new_lines[i]->set_boundary_indicator(quad->boundary_indicator());
+             };
+
+
+
+                                            // now for the quads. again, first
+                                            // collect some data about the
+                                            // indices of the lines, with
+                                            // the following numbering:
+                                            // *5-*-4*
+                                            // 6  10 3
+                                            // *11*-9*
+                                            // 7  8  2
+                                            // *0-*-1*
+           const unsigned int line_indices[12]
+             = { quad->line(0)->child(0)->index(),
+                 quad->line(0)->child(1)->index(),
+                 quad->line(1)->child(0)->index(),
+                 quad->line(1)->child(1)->index(),
+                 quad->line(2)->child(1)->index(),
+                 quad->line(2)->child(0)->index(),
+                 quad->line(3)->child(1)->index(),
+                 quad->line(3)->child(0)->index(),
+                 new_lines[0]->index(),
+                 new_lines[1]->index(),
+                 new_lines[2]->index(),
+                 new_lines[3]->index() 
+             };
+           
+                                            // find some space for the four
+                                            // newly to be created quads.
+                                            // note that there should
+                                            // always be four consecutive
+                                            // free slots for them
+           raw_quad_iterator new_quads[4];
+
+           while (next_unused_quad->used() == true)
+             ++next_unused_quad;
+
+           new_quads[0] = next_unused_quad;
+           Assert (new_quads[0]->used() == false, ExcCellShouldBeUnused());
+
+           ++next_unused_quad;
+           new_quads[1] = next_unused_quad;
+           Assert (new_quads[1]->used() == false, ExcCellShouldBeUnused());
+
+           ++next_unused_quad;
+           new_quads[2] = next_unused_quad;
+           Assert (new_quads[2]->used() == false, ExcCellShouldBeUnused());
+
+           ++next_unused_quad;
+           new_quads[3] = next_unused_quad;
+           Assert (new_quads[3]->used() == false, ExcCellShouldBeUnused());
+
+                                            // note these quads as children
+                                            // to the present one
+           quad->set_children (new_quads[0]->index());
+
+           new_quads[0]->set (Quad(line_indices[0],
+                                   line_indices[8],
+                                   line_indices[11],
+                                   line_indices[7]));
+           new_quads[1]->set (Quad(line_indices[1],
+                                   line_indices[2],
+                                   line_indices[9],
+                                   line_indices[8]));
+           new_quads[2]->set (Quad(line_indices[9],
+                                   line_indices[3],
+                                   line_indices[4],
+                                   line_indices[10]));
+           new_quads[3]->set (Quad(line_indices[11],
+                                   line_indices[10],
+                                   line_indices[5],
+                                   line_indices[6]));
+           for (unsigned int i=0; i<4; ++i)
+             {
+               new_quads[i]->set_used_flag();
+               new_quads[i]->clear_user_flag();
+               new_quads[i]->clear_user_pointer();
+               new_quads[i]->clear_children();
+               new_quads[i]->set_boundary_indicator (quad->boundary_indicator());
+             };  
+           
+                                            // finally clear flag indicating
+                                            // the need for refinement
+           quad->clear_user_flag ();
+         };
+    };
+
+
+                                  ///////////////////////////////////
+                                  // Now, finally, set up the new
+                                  // cells
+  for (unsigned int level=0; level!=levels.size()-1; ++level)
+    {
+                                      // only active objects can be refined
+                                      // further; remember that we won't
+                                      // operate on the finest level, so
+                                      // begin_*(level+1) is allowed
+      active_hex_iterator hex  = begin_active_hex(level),
+                         endh = begin_active_hex(level+1);
+      raw_line_iterator next_unused_line = begin_raw_line (level+1);
+      raw_quad_iterator next_unused_quad = begin_raw_quad (level+1);
+      raw_hex_iterator  next_unused_hex  = begin_raw_hex (level+1);
+
+      for (; hex!=endh; ++hex)
+       if (hex->refine_flag_set())
+         {
+                                            // this hex needs to be refined
+           
+                                            // clear flag indicating
+                                            // the need for refinement. do it
+                                            // here already, since we can't
+                                            // do it anymore once the cell
+                                            // has children
+           hex->clear_refine_flag ();
+
+                                            // find the next unused vertex
+                                            // and set it appropriately
+           while (vertices_used[next_unused_vertex] == true)
+             ++next_unused_vertex;
+           Assert (next_unused_vertex < vertices.size(),
+                   ExcTooFewVerticesAllocated());
+           vertices_used[next_unused_vertex] = true;
+           
+                                            // the new vertex is definitely in
+                                            // the interior, so we need not
+                                            // worry about the boundary.
+                                            // let it be the average of
+                                            // the 26 vertices surrounding
+                                            // it
+           vertices[next_unused_vertex] = Point<dim>();
+                                            // first add corners of hex
+           for (unsigned int vertex=0;
+                vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
+             vertices[next_unused_vertex] += hex->vertex(vertex);
+                                            // now add center of lines
+           for (unsigned int line=0; line<12; ++line)
+             vertices[next_unused_vertex] += hex->line(line)->child(0)->vertex(1);
+                                            // finally add centers of faces
+           for (unsigned int face=0;
+                face<GeometryInfo<dim>::faces_per_cell; ++face)
+             vertices[next_unused_vertex] += hex->face(face)->child(0)->vertex(2);
+
+                                            // compute average
+           vertices[next_unused_vertex] /= 26;
+           
+         
+                                            // now that we created the right
+                                            // point, make up the six
+                                            // lines interior to the quad
+                                            // (++ takes care of the end of
+                                            // the vector)
+           raw_line_iterator new_lines[6];
+
+           for (unsigned int i=0; i<6; ++i)
+             {
+               while (next_unused_line->used() == true)
+                 ++next_unused_line;
+               new_lines[i] = next_unused_line;
+               ++next_unused_line;
+
+               Assert (new_lines[i]->used() == false, ExcCellShouldBeUnused());
+             };
+
+                                            // set the data of the six lines.
+                                            // first collect the indices of
+                                            // the seven vertices (consider
+                                            // the two planes to be crossed
+                                            // to form the planes cutting
+                                            // the hex in two vertically
+                                            // and horizontally)
+                                            //     *--2--*   *--5--*
+                                            //    /  /  /    |  |  |
+                                            //   3--6--1     3--6--1
+                                            //  /  /  /      |  |  |
+                                            // *--0--*       *--4--*
+                                            // the lines are numbered as follows:
+                                            //     *--*--*   *--*--*
+                                            //    /  2  /    |  5  |
+                                            //   *3-*-1*     *3-*-1*
+                                            //  /  0  /      |  4  |
+                                            // *--*--*       *--*--*
+           const unsigned int vertex_indices[7]
+             = { hex->face(0)->child(0)->vertex_index(2),
+                 hex->face(3)->child(0)->vertex_index(2),
+                 hex->face(1)->child(0)->vertex_index(2),
+                 hex->face(5)->child(0)->vertex_index(2),
+                 hex->face(2)->child(0)->vertex_index(2),
+                 hex->face(4)->child(0)->vertex_index(2),
+                 next_unused_vertex 
+             };
+           
+           new_lines[0]->set (Line(vertex_indices[0], vertex_indices[6]));
+           new_lines[1]->set (Line(vertex_indices[6], vertex_indices[1]));
+           new_lines[2]->set (Line(vertex_indices[6], vertex_indices[2]));
+           new_lines[3]->set (Line(vertex_indices[3], vertex_indices[6]));
+           new_lines[4]->set (Line(vertex_indices[4], vertex_indices[6]));
+           new_lines[5]->set (Line(vertex_indices[6], vertex_indices[5]));
+
+           for (unsigned int i=0; i<6; ++i)
+             {
+               new_lines[i]->set_used_flag();
+               new_lines[i]->clear_user_flag();
+               new_lines[i]->clear_user_pointer();
+               new_lines[i]->clear_children();
+                                                // interior line
+               new_lines[i]->set_boundary_indicator(255);
+             };
+
+
+
+                                            // now for the quads. again, first
+                                            // collect some data about the
+                                            // indices of the lines, with
+                                            // the following numbering:
+                                            // front plane    *---*---*
+                                            //                |   2   |
+                                            //                *3--*--1*
+                                            //                |   0   |
+                                            //                *---*---*
+                                            //
+                                            // middle plane   *9--*--8*
+                                            //                10  14  7 
+                                            //                *15-*-13*
+                                            //                11  12  6 
+                                            //                *4--*--5*
+                                            //
+                                            // back plane     *---*---*
+                                            //                |   18  | 
+                                            //                *19-*-17*
+                                            //                |   16  | 
+                                            //                *---*---*
+                                            //
+                                            // left plane (the left-to-right
+                                            // planes are displayed twice each,
+                                            // for better readability of the
+                                            // indices; the left part is
+                                            // already determined by the
+                                            // pictures above)
+                                            //                  *            *
+                                            //                 /|           /| 
+                                            //                * |          * |
+                                            //               /| *         /| *
+                                            //              *10/|        * |21
+                                            //              | * |        | * |
+                                            //              |/| *        |20 *
+                                            //              *11/         * |/
+                                            //              | *          | *
+                                            //              |/           |/ 
+                                            //              *            *
+                                            //
+                                            // middle plane
+                                            //                  *            *
+                                            //                 /|          23| 
+                                            //                * 18         * |
+                                            //               /| *        22| *
+                                            //              *14/16       * |25
+                                            //              | * |        | * |
+                                            //              2/| *        |24 *
+                                            //              *12/         * |27
+                                            //              | *          | *
+                                            //              0/           |26
+                                            //              *            *
+                                            //
+                                            //
+                                            // right plane
+                                            //                  *            *
+                                            //                 /|           /| 
+                                            //                * |          * |
+                                            //               /| *         /| *
+                                            //              * 6/|        * |29
+                                            //              | * |        | * |
+                                            //              |/| *        |28 *
+                                            //              * 7/         * |/
+                                            //              | *          | *
+                                            //              |/           |/
+                                            //              *            *
+              
+           const unsigned int line_indices[30]
+             = {
+                   hex->face(0)->child(0)->line_index(1),   //0
+                   hex->face(0)->child(1)->line_index(2),   //1
+                   hex->face(0)->child(2)->line_index(3),   //2
+                   hex->face(0)->child(3)->line_index(0),   //3
+
+                   hex->face(2)->child(0)->line_index(2),   //4
+                   hex->face(2)->child(1)->line_index(2),   //5
+                   hex->face(3)->child(0)->line_index(1),   //6
+                   hex->face(3)->child(3)->line_index(1),   //7
+
+                   hex->face(4)->child(1)->line_index(2),   //8
+                   hex->face(4)->child(0)->line_index(2),   //9
+                   hex->face(5)->child(3)->line_index(1),   //10
+                   hex->face(5)->child(0)->line_index(1),   //11
+
+                   new_lines[4]->index(),                   //12
+                   new_lines[1]->index(),                   //13
+                   new_lines[5]->index(),                   //14
+                   new_lines[3]->index(),                   //15
+
+                   hex->face(1)->child(0)->line_index(1),   //16
+                   hex->face(1)->child(1)->line_index(2),   //17
+                   hex->face(1)->child(2)->line_index(3),   //18
+                   hex->face(1)->child(3)->line_index(0),   //19
+
+                   hex->face(5)->child(0)->line_index(2),   //20
+                   hex->face(5)->child(1)->line_index(2),   //21
+                   hex->face(4)->child(0)->line_index(1),   //22
+                   hex->face(4)->child(3)->line_index(1),   //23
+
+                   new_lines[0]->index(),                   //24
+                   new_lines[2]->index(),                   //25
+                   hex->face(2)->child(0)->line_index(1),   //26
+                   hex->face(2)->child(3)->line_index(1),   //27
+
+                   hex->face(3)->child(0)->line_index(2),   //28
+                   hex->face(3)->child(1)->line_index(2)    //29
+             };
+           
+                                            // find some space for the 12
+                                            // newly to be created quads.
+           raw_quad_iterator new_quads[12];
+
+           for (unsigned int i=0; i<12; ++i)
+             {
+               while (next_unused_quad->used() == true)
+                 ++next_unused_quad;
+               new_quads[i] = next_unused_quad;
+               ++next_unused_quad;
+
+               Assert (new_quads[i]->used() == false, ExcCellShouldBeUnused());
+             };
+
+                                            // set up the 12 quads, numbered
+                                            // as follows (shown are the three
+                                            // planes cutting the hex in two):
+                                            //
+                                            //  *-----*-----*
+                                            //  |  3  |  2  |
+                                            //  |     |     |
+                                            //  *-----*-----*
+                                            //  |     |     |
+                                            //  |  0  |  1  |
+                                            //  *-----*-----*
+                                            //
+                                            //       *----*----*
+                                            //      / 7  / 6  /
+                                            //     *----*----*
+                                            //    / 4  / 5  /
+                                            //   *----*----*
+                                            //
+                                            //
+                                            //             *
+                                            //            /|
+                                            //           / |
+                                            //          *10|
+                                            //         /|  *
+                                            //        / | /|
+                                            //       *  |/ |
+                                            //       |11*  |
+                                            //       | /| 9*
+                                            //       |/ | /
+                                            //       *  |/
+                                            //       |8 *
+                                            //       | /
+                                            //       |/
+                                            //       *
+           new_quads[0]->set (Quad(line_indices[4],
+                                   line_indices[12],
+                                   line_indices[15],
+                                   line_indices[11]));
+           new_quads[1]->set (Quad(line_indices[5],
+                                   line_indices[6],
+                                   line_indices[13],
+                                   line_indices[12]));
+           new_quads[2]->set (Quad(line_indices[13],
+                                   line_indices[7],
+                                   line_indices[8],
+                                   line_indices[14]));
+           new_quads[3]->set (Quad(line_indices[15],
+                                   line_indices[14],
+                                   line_indices[9],
+                                   line_indices[10]));
+           new_quads[4]->set (Quad(line_indices[3],
+                                   line_indices[24],
+                                   line_indices[15],
+                                   line_indices[20]));
+           new_quads[5]->set (Quad(line_indices[1],
+                                   line_indices[28],
+                                   line_indices[13],
+                                   line_indices[24]));
+           new_quads[6]->set (Quad(line_indices[13],
+                                   line_indices[29],
+                                   line_indices[17],
+                                   line_indices[25]));
+           new_quads[7]->set (Quad(line_indices[15],
+                                   line_indices[25],
+                                   line_indices[19],
+                                   line_indices[21]));
+           new_quads[8]->set (Quad(line_indices[26],
+                                   line_indices[12],
+                                   line_indices[24],
+                                   line_indices[0]));
+           new_quads[9]->set (Quad(line_indices[27],
+                                   line_indices[16],
+                                   line_indices[25],
+                                   line_indices[12]));
+           new_quads[10]->set (Quad(line_indices[25],
+                                   line_indices[18],
+                                   line_indices[23],
+                                   line_indices[14]));
+           new_quads[11]->set (Quad(line_indices[24],
+                                   line_indices[14],
+                                   line_indices[22],
+                                   line_indices[2]));
+           for (unsigned int i=0; i<12; ++i)
+             {
+               new_quads[i]->set_used_flag();
+               new_quads[i]->clear_user_flag();
+               new_quads[i]->clear_user_pointer();
+               new_quads[i]->clear_children();
+                                                // interior quad
+               new_quads[i]->set_boundary_indicator (255);
+             };  
+
+
+                                            /////////////////////////////////
+                                            // create the eight new hexes
+                                            //
+                                            // again first collect some data.
+                                            // here, we need the indices of a
+                                            // whole lotta quads. they are
+                                            // numbered as follows:
+                                            //
+                                            // planes in the interior of
+                                            // the old hex:
+                                            //  *-----*-----*
+                                            //  |  3  |  2  |
+                                            //  |     |     |
+                                            //  *-----*-----*
+                                            //  |     |     |
+                                            //  |  0  |  1  |
+                                            //  *-----*-----*
+                                            //
+                                            //       *----*----*
+                                            //      / 7  / 6  /
+                                            //     *----*----*
+                                            //    / 4  / 5  /
+                                            //   *----*----*
+                                            //
+                                            //
+                                            //             *
+                                            //            /|
+                                            //           / |
+                                            //          *10|
+                                            //         /|  *
+                                            //        / | /|
+                                            //       *  |/ |
+                                            //       |11*  |
+                                            //       | /| 9*
+                                            //       |/ | /
+                                            //       *  |/
+                                            //       |8 *
+                                            //       | /
+                                            //       |/
+                                            //       *
+                                            //
+                                            // children of the faces of the
+                                            // old hex
+                                            //      *-------*        *-------*
+                                            //     /|19   18|       /31   30/|
+                                            //    34|       |      /       /26
+                                            //   /  |       |     /28   29/  |
+                                            //  *   |16   17|    *-------*27 |
+                                            //  3533*-------*    |15   14| 25*
+                                            //  |  /23   22/     |       |  /
+                                            //  32/       /      |       |24
+                                            //  |/20   21/       |12   13|/
+                                            //  *-------*        *-------*
+           const unsigned int quad_indices[36]
+             = {
+                   new_quads[0]->index(),     //0
+                   new_quads[1]->index(),
+                   new_quads[2]->index(),
+                   new_quads[3]->index(),
+                   new_quads[4]->index(),
+                   new_quads[5]->index(),
+                   new_quads[6]->index(),
+                   new_quads[7]->index(),
+                   new_quads[8]->index(),
+                   new_quads[9]->index(),
+                   new_quads[10]->index(),
+                   new_quads[11]->index(),    //11
+
+                   hex->face(0)->child_index(0),  //12
+                   hex->face(0)->child_index(1),
+                   hex->face(0)->child_index(2),
+                   hex->face(0)->child_index(3),
+
+                   hex->face(1)->child_index(0),  //16
+                   hex->face(1)->child_index(1),
+                   hex->face(1)->child_index(2),
+                   hex->face(1)->child_index(3),
+
+                   hex->face(2)->child_index(0),  //20
+                   hex->face(2)->child_index(1),
+                   hex->face(2)->child_index(2),
+                   hex->face(2)->child_index(3),
+
+                   hex->face(3)->child_index(0),  //24
+                   hex->face(3)->child_index(1),
+                   hex->face(3)->child_index(2),
+                   hex->face(3)->child_index(3),
+
+                   hex->face(4)->child_index(0),  //28
+                   hex->face(4)->child_index(1),
+                   hex->face(4)->child_index(2),
+                   hex->face(4)->child_index(3),
+
+                   hex->face(5)->child_index(0),  //32
+                   hex->face(5)->child_index(1),
+                   hex->face(5)->child_index(2),
+                   hex->face(5)->child_index(3)
+             };
+           
+           
+                                            // find some space for the eight
+                                            // newly to be created hexes.
+                                            // note that there should
+                                            // always be eight consecutive
+                                            // free slots for them
+           raw_hex_iterator new_hexes[8];
+
+           while (next_unused_hex->used() == true)
+             ++next_unused_hex;
+
+           for (unsigned int i=0; i<8; ++i)
+             {
+               new_hexes[i] = next_unused_hex;
+               Assert (new_hexes[i]->used() == false, ExcCellShouldBeUnused());
+               ++next_unused_hex;
+             };
+
+                                            // note these hexes as children
+                                            // to the present cell
+           hex->set_children (new_hexes[0]->index());
+
+                                            // front children
+           new_hexes[0]->set (Hexahedron(quad_indices[12],
+                                         quad_indices[0],
+                                         quad_indices[20],
+                                         quad_indices[8],
+                                         quad_indices[4],
+                                         quad_indices[32]));
+           new_hexes[1]->set (Hexahedron(quad_indices[13],
+                                         quad_indices[1],
+                                         quad_indices[21],
+                                         quad_indices[24],
+                                         quad_indices[5],
+                                         quad_indices[8]));
+           new_hexes[2]->set (Hexahedron(quad_indices[14],
+                                         quad_indices[2],
+                                         quad_indices[5],
+                                         quad_indices[27],
+                                         quad_indices[29],
+                                         quad_indices[11]));
+           new_hexes[3]->set (Hexahedron(quad_indices[15],
+                                         quad_indices[3],
+                                         quad_indices[4],
+                                         quad_indices[11],
+                                         quad_indices[28],
+                                         quad_indices[35]));
+           
+                                            // back children
+           new_hexes[4]->set (Hexahedron(quad_indices[0],
+                                         quad_indices[16],
+                                         quad_indices[23],
+                                         quad_indices[9],
+                                         quad_indices[7],
+                                         quad_indices[33]));
+           new_hexes[5]->set (Hexahedron(quad_indices[1],
+                                         quad_indices[17],
+                                         quad_indices[22],
+                                         quad_indices[25],
+                                         quad_indices[6],
+                                         quad_indices[9]));
+           new_hexes[6]->set (Hexahedron(quad_indices[2],
+                                         quad_indices[18],
+                                         quad_indices[6],
+                                         quad_indices[26],
+                                         quad_indices[30],
+                                         quad_indices[10]));
+           new_hexes[7]->set (Hexahedron(quad_indices[3],
+                                         quad_indices[19],
+                                         quad_indices[7],
+                                         quad_indices[10],
+                                         quad_indices[31],
+                                         quad_indices[34]));
+           
+           
+           for (unsigned int i=0; i<8; ++i)
+             {
+               new_hexes[i]->set_used_flag();
+               new_hexes[i]->clear_user_flag();
+               new_hexes[i]->clear_user_pointer();
+               new_hexes[i]->clear_children();
+                                                // inherit material properties
+               new_hexes[i]->set_material_id (hex->material_id());
+             };
+
 
-           subcells[2]->set_neighbor (0, subcells[1]);
-           subcells[2]->set_neighbor (1, neighbors[3]);
-           subcells[2]->set_neighbor (2, neighbors[4]);
-           subcells[2]->set_neighbor (3, subcells[3]);
+                                            /////////////////////////////////
+                                            // now the only thing still to be
+                                            // done is setting neighborship
+                                            // information.
+                                            //
+                                            // to do so, first collect the
+                                            // iterators pointing to
+                                            // the 6x4 neighbors of this
+                                            // cell.
+                                            //
+                                            // note that in case the
+                                            // neighboring cell is not refined,
+                                            // the neighbor iterators point
+                                            // to the common moter cell. the
+                                            // same applies if there is no
+                                            // neighbor: the iterators are
+                                            // past the end
+           cell_iterator neighbor_cells[6][4];
+           for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell;
+                ++face)
+             {
+               cell_iterator neighbor = hex->neighbor(face);
+
+                                                // if no neighbor
+               if (neighbor.state() != valid)
+                 for (unsigned int child_face=0;
+                      child_face<GeometryInfo<dim>::subfaces_per_face;
+                      ++child_face)
+                   neighbor_cells[face][child_face] = neighbor;
+               
+               else
+                                                  // neighbor exists
+                 {
+                                                    // neighbor's level must
+                                                    // not be higher (else
+                                                    // something went wrong
+                                                    // when constructing
+                                                    // either of the two
+                                                    // cells) and not
+                                                    // lower since then
+                                                    // this cell should not
+                                                    // have been refined.
+                   Assert (neighbor->level() == hex->level(),
+                           ExcInternalError());
+
+                                                    // now there are two
+                                                    // possibilities: either
+                                                    // the nieghbor has no
+                                                    // children or it has
+                                                    // children. these
+                                                    // must be terminal then.
+                   if (!neighbor->has_children())
+                     for (unsigned int child_face=0;
+                          child_face<GeometryInfo<dim>::subfaces_per_face;
+                          ++child_face)
+                       neighbor_cells[face][child_face] = neighbor;
+                   else
+                                                      // neighbor has
+                                                      // children; now it's
+                                                      // getting complicated
+                     {
+                                                        // first find the face
+                                                        // of the neighbor
+                                                        // adjacent to which
+                                                        // the present cell is
+                       unsigned int nb_nb;
+                       for (nb_nb=0; nb_nb<GeometryInfo<dim>::faces_per_cell;
+                            ++nb_nb)
+                         if (neighbor->neighbor(nb_nb) == hex)
+                           break;
+                       Assert (nb_nb<GeometryInfo<dim>::faces_per_cell,
+                               ExcInternalError());
+
+                                                        // now the four child
+                                                        // cells of neighbor
+                                                        // adjacent to the
+                                                        // present cell can
+                                                        // be obtained by a
+                                                        // function of
+                                                        // GeometryInfo
+                       for (unsigned int c=0;
+                            c<GeometryInfo<dim>::subfaces_per_face; ++c)
+                         {
+                           neighbor_cells[face][c]
+                             = neighbor->child(GeometryInfo<dim>::child_cell_on_face(nb_nb, c));
+                           
+                           Assert (neighbor_cells[face][c].state() == valid,
+                                   ExcInternalError());
+                           Assert (!neighbor_cells[face][c]->has_children(),
+                                   ExcInternalError());
+                         };
+                     };
+                 };
+             };
 
-           subcells[3]->set_neighbor (0, subcells[0]);
-           subcells[3]->set_neighbor (1, subcells[2]);
-           subcells[3]->set_neighbor (2, neighbors[5]);
-           subcells[3]->set_neighbor (3, neighbors[6]);
+                                            // now we've got all neighbors, so set
+                                            // them in the new cells
+           new_hexes[0]->set_neighbor (0, neighbor_cells[0][0]);
+           new_hexes[0]->set_neighbor (1, new_hexes[4]);
+           new_hexes[0]->set_neighbor (2, neighbor_cells[2][0]);
+           new_hexes[0]->set_neighbor (3, new_hexes[1]);
+           new_hexes[0]->set_neighbor (4, new_hexes[3]);
+           new_hexes[0]->set_neighbor (5, neighbor_cells[5][0]);
+
+           new_hexes[1]->set_neighbor (0, neighbor_cells[0][1]);
+           new_hexes[1]->set_neighbor (1, new_hexes[5]);
+           new_hexes[1]->set_neighbor (2, neighbor_cells[2][1]);
+           new_hexes[1]->set_neighbor (3, neighbor_cells[3][0]);
+           new_hexes[1]->set_neighbor (4, new_hexes[2]);
+           new_hexes[1]->set_neighbor (5, new_hexes[0]);
+
+           new_hexes[2]->set_neighbor (0, neighbor_cells[0][2]);
+           new_hexes[2]->set_neighbor (1, new_hexes[6]);
+           new_hexes[2]->set_neighbor (2, new_hexes[1]);
+           new_hexes[2]->set_neighbor (3, neighbor_cells[3][3]);
+           new_hexes[2]->set_neighbor (4, neighbor_cells[4][1]);
+           new_hexes[2]->set_neighbor (5, new_hexes[3]);
+
+           new_hexes[3]->set_neighbor (0, neighbor_cells[0][3]);
+           new_hexes[3]->set_neighbor (1, new_hexes[7]);
+           new_hexes[3]->set_neighbor (2, new_hexes[0]);
+           new_hexes[3]->set_neighbor (3, new_hexes[2]);
+           new_hexes[3]->set_neighbor (4, neighbor_cells[4][0]);
+           new_hexes[3]->set_neighbor (5, neighbor_cells[5][3]);
+
+           new_hexes[4]->set_neighbor (0, new_hexes[0]);
+           new_hexes[4]->set_neighbor (1, neighbor_cells[1][0]);
+           new_hexes[4]->set_neighbor (2, neighbor_cells[2][3]);
+           new_hexes[4]->set_neighbor (3, new_hexes[5]);
+           new_hexes[4]->set_neighbor (4, new_hexes[7]);
+           new_hexes[4]->set_neighbor (5, neighbor_cells[5][1]);
+
+           new_hexes[5]->set_neighbor (0, new_hexes[1]);
+           new_hexes[5]->set_neighbor (1, neighbor_cells[1][1]);
+           new_hexes[5]->set_neighbor (2, neighbor_cells[2][2]);
+           new_hexes[5]->set_neighbor (3, neighbor_cells[3][1]);
+           new_hexes[5]->set_neighbor (4, new_hexes[6]);
+           new_hexes[5]->set_neighbor (5, new_hexes[4]);
+
+           new_hexes[6]->set_neighbor (0, new_hexes[2]);
+           new_hexes[6]->set_neighbor (1, neighbor_cells[1][2]);
+           new_hexes[6]->set_neighbor (2, new_hexes[5]);
+           new_hexes[6]->set_neighbor (3, neighbor_cells[3][2]);
+           new_hexes[6]->set_neighbor (4, neighbor_cells[4][2]);
+           new_hexes[6]->set_neighbor (5, new_hexes[7]);
+
+           new_hexes[7]->set_neighbor (0, new_hexes[3]);
+           new_hexes[7]->set_neighbor (1, neighbor_cells[1][3]);
+           new_hexes[7]->set_neighbor (2, new_hexes[4]);
+           new_hexes[7]->set_neighbor (3, new_hexes[6]);
+           new_hexes[7]->set_neighbor (4, neighbor_cells[4][3]);
+           new_hexes[7]->set_neighbor (5, neighbor_cells[5][2]);
+
+
+                                            // now we need to set the neighbors
+                                            // neighborship information; this
+                                            // is only necessary if the
+                                            // neighboring cell is refined,
+                                            // i.e. is on the same level as
+                                            // the new children of the
+                                            // present cell
+           for (unsigned int nb=0; nb<GeometryInfo<dim>::faces_per_cell; ++nb)
+             for (unsigned int subface=0;
+                  subface<GeometryInfo<dim>::subfaces_per_face; ++subface)
+               if ((neighbor_cells[nb][subface].state() == valid) &&
+                   (neighbor_cells[nb][subface]->level() ==
+                    hex->level()+1))
+                 {
+                                                    // ok, the neighbor is
+                                                    // a refined one and we
+                                                    // need to set one of
+                                                    // the new children as
+                                                    // its neighbor
+                   cell_iterator neighbor = neighbor_cells[nb][subface];
+
+                                                    // find which neighbor
+                                                    // pointer is to be reset;
+                                                    // this pointer still
+                                                    // points to the present
+                                                    // cell
+                   unsigned int face;
+                   for (face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+                     if (neighbor->neighbor(face) == hex)
+                       break;
+
+                   Assert (face<GeometryInfo<dim>::faces_per_cell,
+                           ExcInternalError());
+
+                                                    // now neighbor->neighbor(face)
+                                                    // needs to be reset. do a
+                                                    // large switch statement to
+                                                    // find out which of the
+                                                    // eight children is next
+                                                    // to the face/subface we
+                                                    // are presently at
+                   static const unsigned int child_on_face_and_subface[6][4]
+                     = {  
+                           {0, 1, 2, 3},
+                           {4, 5, 6, 7},
+                           {0, 1, 5, 4},
+                           {1, 5, 6, 2},
+                           {3, 2, 6, 7},
+                           {0, 4, 7, 3}
+                     };
+                   neighbor->set_neighbor(face,
+                                          new_hexes[child_on_face_and_subface[nb][subface]]);
+                 };
 
-           subcells[0]->set_material_id (cell->material_id());
-           subcells[1]->set_material_id (cell->material_id());
-           subcells[2]->set_material_id (cell->material_id());
-           subcells[3]->set_material_id (cell->material_id());
+                   
+           
+                                            // note that the refinement
+                                            // flag was already cleared at
+                                            // the beginning of this loop
          };
     };
+
+
 #ifdef DEBUG
   for (unsigned int level=0; level<levels.size(); ++level) 
-    levels[level]->monitor_memory (2);
+    levels[level]->monitor_memory (3);
 
                                   // check whether really all refinement flags
                                   // are reset (also of previously non-active
@@ -3253,6 +5954,16 @@ void Triangulation<2>::execute_refinement () {
                                   // the refinement flag of a non-active cell
                                   // is set, something went wrong since the
                                   // cell-accessors should have caught this)
+  line_iterator line = begin_line(),
+               endl = end_line();
+  while (line != endl)
+    Assert (!(line++)->user_flag_set(), ExcInternalError ());
+
+  quad_iterator quad = begin_quad(),
+               endq = end_quad();
+  while (quad != endq)
+    Assert (!(quad++)->user_flag_set(), ExcInternalError ());
+
   cell_iterator cell = begin(),
                endc = end();
   while (cell != endc)
@@ -3260,6 +5971,8 @@ void Triangulation<2>::execute_refinement () {
 #endif
 };
 
+
+
 #endif
 
 
@@ -3352,7 +6065,10 @@ bool Triangulation<dim>::prepare_refinement () {
       do
        {
          mesh_changed_in_this_loop = false;
-      
+
+                                          // do some dimension dependent stuff
+         mesh_changed_in_this_loop |= prepare_refinement_dim_dependent ();
+         
                                           // store highest level one of the cells
                                           // adjacent to a vertex belongs to; do
                                           // so only if mesh smoothing is
@@ -3483,6 +6199,117 @@ bool Triangulation<dim>::prepare_refinement () {
 
 
 
+template <int dim>
+bool Triangulation<dim>::prepare_refinement_dim_dependent () 
+{
+  return false;
+};
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+bool Triangulation<3>::prepare_refinement_dim_dependent () 
+{
+  const unsigned int dim = 3;
+  
+                                  // first clear flags on lines, since
+                                  // we need them to determine which
+                                  // lines will be refined
+  for (line_iterator line=begin_line(); line!=end_line(); ++line)
+    line->clear_user_flag();
+
+                                  // variables to store whether the mesh was
+                                  // changed in the present loop and in the
+                                  // whole process
+  bool mesh_changed      = false,
+       mesh_changed_once = false;
+
+  do
+    {
+      mesh_changed = false;
+
+                                      // flag those lines that will be refined
+      for (active_cell_iterator cell=begin_active(); cell!=end(); ++cell)
+       if (cell->refine_flag_set())
+         for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+                                            // if the line is not yet refined,
+                                            // it will be in the process
+           if (!cell->line(line)->has_children())
+             cell->line(line)->set_user_flag();
+
+
+                                      // now check whether there are cell with
+                                      // lines that are more than once refined
+                                      // or that will be more than once
+                                      // refined. The first thing should never
+                                      // be the case, in the second case we
+                                      // flag the cell for refinement
+      for (active_cell_iterator cell=last_active(); cell!=end(); --cell)
+       for (unsigned int line=0; line<GeometryInfo<dim>::lines_per_cell; ++line)
+         if (cell->line(line)->has_children())
+           {
+                                              // if this line is refined, its
+                                              // children should not have
+                                              // further children
+                                              //
+                                              // however, if any of the
+                                              // children is flagged for
+                                              // further refinement, we need
+                                              // to refine this cell also
+                                              // (at least, if the cell is
+                                              // not already flagged)
+             bool offending_line_found = false;
+             
+             for (unsigned int c=0; c<2; ++c)
+               {
+                 Assert (cell->line(line)->child(c)->has_children() == false,
+                         ExcInternalError());
+
+                 if (cell->line(line)->child(c)->user_flag_set () &&
+                     !cell->refine_flag_set())
+                   {
+                     cell->set_refine_flag();
+                     offending_line_found = true;
+
+                                                      // it may save us several
+                                                      // loop iterations if we
+                                                      // flag all lines of
+                                                      // this cell now (and not
+                                                      // at the outset of the
+                                                      // next iteration) for
+                                                      // refinement
+                     for (unsigned int line=0;
+                          line<GeometryInfo<dim>::lines_per_cell; ++line)
+                       if (!cell->line(line)->has_children())
+                         cell->line(line)->set_user_flag();
+                     
+                     break;
+                   };
+               };
+
+             if (offending_line_found)
+               {
+                 mesh_changed = true;
+                 break;
+               };
+             
+           };
+      
+                 
+
+      
+      mesh_changed_once |= mesh_changed;
+    }
+  while (mesh_changed == true);
+
+  return mesh_changed_once;
+};
+
+#endif
+
+
 
 template <int dim>
 bool Triangulation<dim>::prepare_coarsening () {
@@ -3795,6 +6622,12 @@ void Triangulation<2>::delete_cell (cell_iterator &cell) {
   cell->child(2)->line(0)->clear_user_pointer();
   cell->child(2)->line(3)->clear_user_pointer();
   
+                                  // same for user flags
+  cell->child(0)->line(1)->clear_user_flag();
+  cell->child(0)->line(2)->clear_user_flag();
+  cell->child(2)->line(0)->clear_user_flag();
+  cell->child(2)->line(3)->clear_user_flag();
+  
                                   // delete the four interior lines
   cell->child(0)->line(1)->clear_used_flag();
   cell->child(0)->line(2)->clear_used_flag();
@@ -3820,6 +6653,7 @@ void Triangulation<2>::delete_cell (cell_iterator &cell) {
             subface<GeometryInfo<dim>::subfaces_per_face; ++subface)
          {
            cell->face(face)->child(subface)->clear_user_pointer ();
+           cell->face(face)->child(subface)->clear_user_flag ();
            cell->face(face)->child(subface)->clear_used_flag ();
          };
        
@@ -3830,6 +6664,7 @@ void Triangulation<2>::delete_cell (cell_iterator &cell) {
   for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
     {
       cell->child(child)->clear_user_pointer();
+      cell->child(child)->clear_user_flag();
       cell->child(child)->clear_used_flag();
     };
   
@@ -3843,6 +6678,330 @@ void Triangulation<2>::delete_cell (cell_iterator &cell) {
 
 
 
+#if deal_II_dimension == 3
+
+
+template <>
+void Triangulation<3>::delete_cell (cell_iterator &cell) {
+  const unsigned int dim=3;
+                                  // first we need to reset the
+                                  // neighbor pointers of the neighbors
+                                  // of this cell's children to this
+                                  // cell. This is different for one
+                                  // dimension, since there neighbors
+                                  // can have a refinement level
+                                  // differing from that of this cell's
+                                  // children by more than one level.
+                                  // For two or more dimensions, the
+                                  // neighbors of the children may only
+                                  // be on the same level or on the level
+                                  // of this cell (the case that the
+                                  // neighbors are more refined than
+                                  // the children was eliminated in
+                                  // #prepare_coarsening#
+  for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
+    for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell; ++n)
+      {
+       const cell_iterator neighbor = cell->child(child)->neighbor(n);
+                                        // do nothing if at boundary
+       if (neighbor.state() != valid)
+         continue;
+       
+       Assert ((neighbor->level()==cell->level()) ||
+               (neighbor->level()==cell->level()+1),
+               ExcInternalError());
+       
+                                        // if the neighbor's level is the
+                                        // same as that of #cell#, then
+                                        // it's neighbor pointers points
+                                        // to this cell rather than to
+                                        // this cell's child. In that
+                                        // case we need not do anything.
+                                        // If the neighbor is refined
+                                        // as often as are the children,
+                                        // we need to reset those neigbor
+                                        // pointers that point to the
+                                        // child of this cell; when
+                                        // resetting the neighbor
+                                        // pointers of neighbors of one
+                                        // of the children, we will also
+                                        // reset the neighbor pointers
+                                        // other children to the present
+                                        // cell, but this does no harm
+                                        // since we delete the children
+                                        // afterwards anyway
+       if (neighbor->level() == cell->level()+1)
+         for (unsigned int neighbor_neighbor=0;
+              neighbor_neighbor<GeometryInfo<dim>::faces_per_cell;
+              ++neighbor_neighbor)
+           if (neighbor->neighbor(neighbor_neighbor) == cell->child(child))
+             neighbor->set_neighbor(neighbor_neighbor, cell);
+      };
+
+                                  // delete the vertex which will not be
+                                  // needed anymore. This vertex is the
+                                  // vertex at the heart of this cell,
+                                  // which is the sixth of the 
+                                  // first child
+  vertices_used[cell->child(0)->vertex_index(6)] = false;
+
+                                  ///////////////////////////////////////
+                                  // delete interior quads and lines
+                                  //
+                                  // first set up a list of these
+                                  // line's and quad's indices
+  const quad_iterator interior_quads[12]
+    = {  cell->child(0)->face(1),
+        cell->child(1)->face(1),
+        cell->child(2)->face(1),
+        cell->child(3)->face(1),
+
+        cell->child(0)->face(3),
+        cell->child(3)->face(3),
+        cell->child(4)->face(3),
+        cell->child(7)->face(3),
+
+        cell->child(0)->face(4),
+        cell->child(1)->face(4),
+        cell->child(4)->face(4),
+        cell->child(5)->face(4) 
+    };
+
+  const line_iterator interior_lines[6]
+    = {  cell->child(0)->line(10),
+        cell->child(4)->line(10),
+
+        cell->child(0)->line(6),
+        cell->child(1)->line(6),
+
+        cell->child(0)->line(5),
+        cell->child(3)->line(5) 
+    };
+
+                                  // clear user pointers, to avoid that
+                                  // they may appear at unwanted places
+                                  // later on...
+                                  // same for user flags, then finally
+                                  // delete thes quads and lines
+  for (unsigned int q=0; q<12; ++q)
+    {
+      interior_quads[q]->clear_user_pointer();
+      interior_quads[q]->clear_user_flag();
+      interior_quads[q]->clear_used_flag();
+    };
+
+  for (unsigned int l=0; l<6; ++l)
+    {
+      interior_lines[l]->clear_user_pointer();
+      interior_lines[l]->clear_user_flag();
+      interior_lines[l]->clear_used_flag();
+    };
+
+                                  // for the six faces: if the neighbor
+                                  // does not itself need the subfaces,
+                                  // delete them. note that since dim>1
+                                  // the level of a neighbor is either
+                                  // one less or the same as that of
+                                  // cell
+  for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face) 
+    if ((cell->neighbor(face).state() != valid) ||
+       (cell->neighbor(face)->level() == cell->level()-1) ||
+       ((cell->neighbor(face)->level() == cell->level()) &&
+        !cell->neighbor(face)->has_children()))
+      {
+       quad_iterator quad = cell->face(face);
+       
+                                        // delete middle vertex
+       vertices_used[quad->child(0)->vertex_index(2)] = false;
+
+       const line_iterator interior_lines[4]
+         = { quad->child(0)->line(1),
+             quad->child(0)->line(2),
+             quad->child(2)->line(0),
+             quad->child(2)->line(3) 
+         };
+
+                                        // delete interior lines
+       for (unsigned int l=0; l<4; ++l)
+         {
+           interior_lines[l]->clear_user_pointer ();
+           interior_lines[l]->clear_user_flag ();
+           interior_lines[l]->clear_used_flag ();
+         };
+       
+                                        // delete the four subfaces
+       for (unsigned int subface=0;
+            subface<GeometryInfo<dim>::subfaces_per_face; ++subface)
+         {
+           quad->child(subface)->clear_user_pointer ();
+           quad->child(subface)->clear_user_flag ();
+           quad->child(subface)->clear_used_flag ();
+         };
+       
+       quad->clear_children();
+      };
+
+                                  // invalidate children
+  for (unsigned int child=0; child<GeometryInfo<dim>::children_per_cell; ++child)
+    {
+      cell->child(child)->clear_user_pointer();
+      cell->child(child)->clear_user_flag();
+      cell->child(child)->clear_used_flag();
+    };
+  
+  
+                                  // delete pointer to children
+  cell->clear_children ();
+  cell->clear_user_flag();
+
+                                  // now there still are the 12 lines of
+                                  // this hex which are refined and which
+                                  // may need coarsening. however, it is not
+                                  // so easy to decide whether they are still
+                                  // needed, since it does not suffice to
+                                  // ask the neighbors. we also need to ask
+                                  // those cells, which are "around the
+                                  // corner".
+                                  //
+                                  // to do so: first set up a list of 12 pairs
+                                  // of line_iterators and flags which denote
+                                  // whether the line's children are still
+                                  // needed
+                                  //
+                                  // we default to: "is not needed" because in
+                                  // this case, if we make an error in the code
+                                  // below, some lines will be deleted that in
+                                  // fact are needed. this will eventually be
+                                  // caught somewhen, because there are many
+                                  // checks whether an iterator points to
+                                  // something used. the opposite case, that
+                                  // we do not delete lines that are no more
+                                  // used, is more severe and causes a memory
+                                  // leak which is probably impossible to
+                                  // find.
+  const pair<line_iterator,bool> line_is_needed_pairs[12]
+    = { make_pair(cell->line(0), false),
+       make_pair(cell->line(1), false),
+       make_pair(cell->line(2), false),
+       make_pair(cell->line(3), false),
+       make_pair(cell->line(4), false),
+       make_pair(cell->line(5), false),
+       make_pair(cell->line(6), false),
+       make_pair(cell->line(7), false),
+       make_pair(cell->line(8), false),
+       make_pair(cell->line(9), false),
+       make_pair(cell->line(0), false),
+       make_pair(cell->line(11), false)  };
+                                  // next make a map out of this for simpler
+                                  // access to the flag associated with a
+                                  // line
+  map<line_iterator,bool> line_is_needed (&line_is_needed_pairs[0],
+                                         &line_is_needed_pairs[12]);
+  
+                                  // then ask each neighbor and their neighbors
+  for (unsigned int nb=0; nb<GeometryInfo<dim>::faces_per_cell; ++nb) 
+    {
+      const cell_iterator neighbor = cell->neighbor(nb);
+                                        // do nothing if at boundary
+      if (neighbor.state() != valid)
+       continue;
+
+      Assert (neighbor->level() == cell->level(),
+             ExcInternalError());
+
+                                      // if the neighbor itself has
+                                      // children, then the four lines
+                                      // of the common face are definitely
+                                      // needed
+      if (neighbor->has_children())
+       {
+         for (unsigned int i=0; i<4; ++i)
+           {
+             Assert (line_is_needed.find(cell->face(nb)->line(i))
+                     != line_is_needed.end(),
+                     ExcInternalError());
+             
+             line_is_needed[cell->face(nb)->line(i)] = true;
+           };
+                                          // ok for this neighbor
+         break;
+       };
+
+                                      // if the neighbor is not refined,
+                                      // then it may still be that one of
+                                      // his neighbors may need one of our
+                                      // lines. the present cell is also
+                                      // one of his neighbors, but this one
+                                      // is not any more refined
+      for (unsigned int nb_nb=0; nb_nb<GeometryInfo<dim>::faces_per_cell;
+          ++nb_nb)
+       {
+         const cell_iterator neighbor_neighbor = neighbor->neighbor(nb_nb);
+                                          // do nothing if at boundary
+         if (neighbor_neighbor.state() != valid)
+           continue;
+
+         Assert ((neighbor_neighbor->level() == cell->level()) ||
+                 (neighbor_neighbor->level() == cell->level()-1),
+                 ExcInternalError());
+         
+                                          // also do nothing if the neighbor
+                                          // is at a lower level (but then it
+                                          // should not be refined)
+         if (neighbor_neighbor->level() == cell->level()-1)
+           {
+             Assert (!neighbor_neighbor->has_children(),
+                     ExcInternalError());
+             continue;
+           };
+
+                                          // neighbor's neighbor is on
+                                          // same level. if it has children,
+                                          // then look closer
+         if (neighbor_neighbor->has_children())
+                                            // if any of those cell's lines
+                                            // is one of those that we are
+                                            // interested in, then flag it
+           for (unsigned int l=0; l<GeometryInfo<dim>::lines_per_cell; ++l)
+             {
+               line_iterator line = neighbor_neighbor->line(l);
+
+               if (line_is_needed.find(line) != line_is_needed.end())
+                 line_is_needed[line] = true;
+             };
+       };
+    };
+
+  Assert (line_is_needed.size()==12, ExcInternalError());
+
+  
+                                  // now, if the lines are not marked as
+                                  // needed, we may delete their children
+                                  // and the midpoint
+  map<line_iterator,bool>::iterator line_and_flag;
+  for (line_and_flag=line_is_needed.begin();
+       line_and_flag!=line_is_needed.end(); ++line_and_flag)
+    if  (line_and_flag->second == false)
+      {
+       line_iterator line = line_and_flag->first;
+
+       vertices_used[line->child(0)->vertex_index(1)] = false;
+
+       for (unsigned int child=0; child<2; ++child)
+         {
+           line->child(child)->clear_user_pointer();
+           line->child(child)->clear_user_flag();
+           line->child(child)->clear_used_flag();
+         };
+
+       line->clear_children();
+      };
+};
+
+#endif
+
+
+
 template <int dim>
 void Triangulation<dim>::write_bool_vector (const unsigned int  magic_number1,
                                            const vector<bool> &v,
@@ -4118,6 +7277,78 @@ void TriangulationLevel<2>::monitor_memory (const unsigned int true_dimension) c
 #endif
 
 
+#if deal_II_dimension >= 3
+
+void TriangulationLevel<3>::reserve_space (const unsigned int new_hexes) {
+  const unsigned int new_size = new_hexes +
+                               count_if (hexes.used.begin(),
+                                         hexes.used.end(),
+                                         bind2nd (equal_to<bool>(), true));
+
+                                  // see above...
+  if (new_size>hexes.hexes.size())
+    {
+      hexes.hexes.reserve (new_size);
+      hexes.hexes.insert (hexes.hexes.end(), new_size-hexes.hexes.size(), Hexahedron());
+      
+      hexes.used.reserve (new_size);
+      hexes.used.insert (hexes.used.end(), new_size-hexes.used.size(), false);
+  
+      hexes.user_flags.reserve (new_size);
+      hexes.user_flags.insert (hexes.user_flags.end(),
+                              new_size-hexes.user_flags.size(), false);
+  
+      hexes.children.reserve (new_size);
+      hexes.children.insert (hexes.children.end(), new_size-hexes.children.size(),
+                            -1);
+
+      hexes.material_id.reserve (new_size);
+      hexes.material_id.insert (hexes.material_id.end(),
+                               new_size-hexes.material_id.size(),
+                               255);
+
+      hexes.user_pointers.reserve (new_size);
+      hexes.user_pointers.insert (hexes.user_pointers.end(),
+                                 new_size-hexes.user_pointers.size(), 0);
+    };
+};
+
+
+
+void TriangulationLevel<3>::monitor_memory (const unsigned int true_dimension) const {
+//  Assert (hexes.hexes.size() == hexes.hexes.capacity() ||
+//       hexes.hexes.size()<256,
+//       ExcMemoryWasted ("hexes",
+//                        hexes.hexes.size(), hexes.hexes.capacity()));
+//  Assert (hexes.children.size() == hexes.children.capacity() ||
+//       hexes.children.size()<256,
+//       ExcMemoryWasted ("children",
+//                        hexes.children.size(), hexes.children.capacity()));
+//  Assert (hexes.used.size() == hexes.used.capacity() ||
+//       hexes.used.size()<256,
+//       ExcMemoryWasted ("used",
+//                        hexes.used.size(), hexes.used.capacity()));
+//  Assert (hexes.user_flags.size() == hexes.user_flags.capacity() ||
+//       hexes.user_flags.size()<256,
+//       ExcMemoryWasted ("user_flags",
+//                        hexes.user_flags.size(), hexes.user_flags.capacity()));
+  Assert (hexes.hexes.size() == hexes.used.size(),
+         ExcMemoryInexact (hexes.hexes.size(), hexes.used.size()));
+  Assert (hexes.hexes.size() == hexes.user_flags.size(),
+         ExcMemoryInexact (hexes.hexes.size(), hexes.user_flags.size()));
+  Assert (hexes.hexes.size() == hexes.children.size(),
+         ExcMemoryInexact (hexes.hexes.size(), hexes.children.size()));
+  Assert (hexes.hexes.size() == hexes.material_id.size(),
+         ExcMemoryInexact (hexes.hexes.size(), hexes.material_id.size()));
+  Assert (hexes.hexes.size() == hexes.user_pointers.size(),
+         ExcMemoryInexact (hexes.hexes.size(), hexes.user_pointers.size()));
+
+  TriangulationLevel<2>::monitor_memory (true_dimension);
+};
+
+#endif
+
+
 
 
 // explicit instantiations
index dd43ba13c3333bfecca67c6c5e635f43de5d55bf..2d46e82d28462ade4ab7bb6d284468007d7c8a95 100644 (file)
@@ -8,9 +8,8 @@
 #include <grid/tria_accessor.h>
 #include <grid/tria_iterator.templates.h>
 #include <grid/geometry_info.h>
-#include <math.h>
 
-/* Note: explicit instantiations at the end of the different sections!       */
+#include <cmath>
 
 
 
@@ -221,6 +220,9 @@ int LineAccessor<dim>::child_index (unsigned int i) const {
 template <int dim>
 void LineAccessor<dim>::set_children (const int index) const {
   Assert (used(), ExcCellNotUsed());
+  Assert ((index==-1) ||
+         (!has_children() && (index>=0)), ExcCantSetChildren(index));
+  
   tria->levels[present_level]->lines.children[present_index] = index;
 };
 
@@ -513,7 +515,7 @@ TriaIterator<dim,QuadAccessor<dim> >
 QuadAccessor<dim>::child (const unsigned int i) const {
   Assert (i<4, ExcInvalidIndex(i,0,3));
   
-  TriaIterator<2,QuadAccessor<dim> > q (tria, present_level+1, child_index (i));
+  TriaIterator<dim,QuadAccessor<dim> > q (tria, present_level+1, child_index (i));
   
 #ifdef DEBUG
   if (q.state() != past_the_end)
@@ -535,6 +537,9 @@ int QuadAccessor<dim>::child_index (unsigned int i) const {
 template <int dim>
 void QuadAccessor<dim>::set_children (const int index) const {
   Assert (used(), ExcCellNotUsed());
+  Assert ((index==-1) ||
+         (!has_children() && (index>=0)), ExcCantSetChildren(index));
+
   tria->levels[present_level]->quads.children[present_index] = index;
 };
 
@@ -656,7 +661,7 @@ Point<2> QuadAccessor<2>::barycenter () const {
                                   // for 2D and 3D separately
 /*
   Get the computation of the barycenter by this little Maple script. We
-  use the blinear mapping of the unit quad to the real quad. However,
+  use the bilinear mapping of the unit quad to the real quad. However,
   every transformation mapping the unit faces to strait lines should
   do.
 
@@ -791,6 +796,1078 @@ unsigned int QuadAccessor<dim>::number_of_children () const {
 
 
 
+/*------------------------ Functions: HexAccessor ---------------------------*/
+
+template <int dim>
+void HexAccessor<dim>::set (const Hexahedron &hex) const {
+  tria->levels[present_level]->hexes.hexes[present_index] = hex;
+};
+
+
+
+template <int dim>
+int HexAccessor<dim>::vertex_index (const unsigned int corner) const {
+  Assert (corner<8, ExcInvalidIndex(corner,0,7));
+
+                                  // get the corner indices by asking
+                                  // either the front or the back face
+                                  // for its vertices.
+  if (corner<4)
+    return quad(0)->vertex_index(corner);
+  else
+    return quad(1)->vertex_index(corner-4);
+};
+
+
+
+template <int dim>
+Point<dim> &
+HexAccessor<dim>::vertex (const unsigned int i) const {
+  return tria->vertices[vertex_index(i)];
+};
+
+
+
+template <int dim>
+bool HexAccessor<dim>::used () const {
+  Assert (state() == valid, ExcDereferenceInvalidObject());
+  return tria->levels[present_level]->hexes.used[present_index];
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::set_used_flag () const {
+  Assert (state() == valid, ExcDereferenceInvalidObject());
+  tria->levels[present_level]->hexes.used[present_index] = true;
+};
+  
+
+
+template <int dim>
+void HexAccessor<dim>::clear_used_flag () const {
+  Assert (state() == valid, ExcDereferenceInvalidObject());
+  tria->levels[present_level]->hexes.used[present_index] = false;
+};
+
+
+
+
+template <int dim>
+bool HexAccessor<dim>::user_flag_set () const {
+  Assert (used(), ExcCellNotUsed());
+  return tria->levels[present_level]->hexes.user_flags[present_index];
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::set_user_flag () const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->hexes.user_flags[present_index] = true;
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::clear_user_flag () const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->hexes.user_flags[present_index] = false;
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::recursively_set_user_flag () const {
+  set_user_flag ();
+
+  if (has_children())
+    for (unsigned int c=0; c<8; ++c)
+      child(c)->recursively_set_user_flag ();
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::recursively_clear_user_flag () const {
+  clear_user_flag ();
+
+  if (has_children())
+    for (unsigned int c=0; c<8; ++c)
+      child(c)->recursively_clear_user_flag ();
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::set_user_pointer (void *p) const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->hexes.user_pointers[present_index] = p;
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::clear_user_pointer () const {
+  Assert (used(), ExcCellNotUsed());
+  tria->levels[present_level]->hexes.user_pointers[present_index] = 0;
+};
+
+
+
+template <int dim>
+void * HexAccessor<dim>::user_pointer () const {
+  Assert (used(), ExcCellNotUsed());
+  return tria->levels[present_level]->hexes.user_pointers[present_index];
+};
+
+
+
+
+template <int dim>
+TriaIterator<dim,LineAccessor<dim> >
+HexAccessor<dim>::line (const unsigned int i) const {
+  Assert (used(), ExcCellNotUsed());
+  Assert (i<12, ExcInvalidIndex (i,0,11));
+  
+  if (i<4)
+    return quad(0)->line(i);
+  else
+    if (i<8)
+      return quad(1)->line(i-4);
+    else
+      switch (i) 
+       {
+         case 8:
+               return quad(2)->line(3);
+         case 9:
+               return quad(2)->line(1);
+         case 10:
+               return quad(4)->line(1);
+         case 11:
+               return quad(4)->line(3);
+       };
+  Assert (false, ExcInvalidIndex(i,0,11));
+  return TriaIterator<dim,LineAccessor<dim> >(tria, -1, -1, 0);
+};
+
+
+
+template <int dim>
+TriaIterator<dim,QuadAccessor<dim> >
+HexAccessor<dim>::quad (const unsigned int i) const {
+  Assert (used(), ExcCellNotUsed());
+  return
+    TriaIterator<dim,QuadAccessor<dim> >
+    (
+      tria,
+      present_level,
+      quad_index (i)
+    );
+};
+
+
+
+template <int dim>
+unsigned int HexAccessor<dim>::quad_index (unsigned int i) const {
+  Assert (i<6, ExcInvalidIndex(i,0,5));
+
+  return tria->levels[present_level]->hexes.hexes[present_index].quad(i);
+};
+
+
+
+template <int dim>
+TriaIterator<dim,HexAccessor<dim> >
+HexAccessor<dim>::child (const unsigned int i) const {
+  Assert (i<6, ExcInvalidIndex(i,0,5));
+  
+  TriaIterator<dim,HexAccessor<dim> > q (tria, present_level+1, child_index (i));
+  
+#ifdef DEBUG
+  if (q.state() != past_the_end)
+    Assert (q->used(), ExcUnusedCellAsChild());
+#endif
+  return q;
+};
+
+
+
+template <int dim>
+int HexAccessor<dim>::child_index (unsigned int i) const {
+  Assert (i<8, ExcInvalidIndex(i,0,7));
+  return tria->levels[present_level]->hexes.children[present_index]+i;
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::set_children (const int index) const {
+  Assert (used(), ExcCellNotUsed());
+  Assert ((index==-1) ||
+         (!has_children() && (index>=0)), ExcCantSetChildren(index));
+
+  tria->levels[present_level]->hexes.children[present_index] = index;
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::clear_children () const {
+  set_children (-1);
+};
+
+
+
+template <int dim>
+bool HexAccessor<dim>::has_children () const {
+  Assert (state() == valid, ExcDereferenceInvalidObject());
+  return (tria->levels[present_level]->hexes.children[present_index] != -1);
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::operator ++ () {
+  ++present_index;
+                                  // is index still in the range of
+                                  // the vector?
+  while (present_index
+        >=
+        (int)tria->levels[present_level]->hexes.hexes.size()) 
+    {
+                                      // no -> go one level up
+      ++present_level;
+      present_index = 0;
+                                      // highest level reached?
+      if (present_level >= (int)tria->levels.size()) 
+       {
+                                          // return with past the end pointer
+         present_level = present_index = -1;
+         return;
+       };
+    };
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::operator -- () {
+  --present_index;
+                                  // is index still in the range of
+                                  // the vector?
+  while (present_index < 0) 
+    {
+                                      // no -> go one level down
+      --present_level;
+                                      // lowest level reached?
+      if (present_level == -1) 
+       {
+                                          // return with past the end pointer
+         present_level = present_index = -1;
+         return;
+       };
+                                      // else
+      present_index = tria->levels[present_level]->hexes.hexes.size()-1;
+    };
+};
+
+
+
+template <int dim>
+unsigned char HexAccessor<dim>::boundary_indicator () const {
+  Assert (dim<4, ExcNotUsefulForThisDimension());
+  Assert (used(), ExcCellNotUsed());
+
+  return tria->levels[present_level]->hexes.material_id[present_index];
+};
+
+
+
+template <int dim>
+void HexAccessor<dim>::set_boundary_indicator (unsigned char boundary_ind) const {
+  Assert (dim<4, ExcNotUsefulForThisDimension());
+  Assert (used(), ExcCellNotUsed());
+
+  tria->levels[present_level]->hexes.material_id[present_index] = boundary_ind;
+};
+
+
+
+template <int dim>
+bool HexAccessor<dim>::at_boundary () const {
+                                  // error checking is done
+                                  // in boundary_indicator()
+  return (boundary_indicator() != 255);
+};
+
+
+
+template <int dim>
+double HexAccessor<dim>::diameter () const {
+  return sqrt(max( max((vertex(6)-vertex(0)).square(),
+                      (vertex(7)-vertex(1)).square()),
+                  max((vertex(4)-vertex(2)).square(),
+                      (vertex(5)-vertex(3)).square()) ));
+};
+
+
+
+template <int dim>
+Point<dim> HexAccessor<dim>::center () const {
+  return (vertex(0)+vertex(1)+vertex(2)+vertex(3)+
+         vertex(4)+vertex(5)+vertex(6)+vertex(7))/8.;
+};
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+Point<3> HexAccessor<3>::barycenter () const {
+/*
+  Get the computation of the barycenter by this little Maple script. We
+  use the trilinear mapping of the unit hex to the real hex.
+
+  Remember that the area of the hex is given by
+  |K| = \int_K 1 dx dy dz = \int_{\hat K} |det J| d(xi) d(eta) d(zeta)
+  and that the barycenter is given by
+  \vec x_s = 1/|K| \int_K \vec x dx dy dz
+           = 1/|K| \int_{\hat K} \vec x(xi,eta,zeta) |det J| d(xi) d(eta) d(zeta)
+
+  # x, y and z are arrays holding the x-, y- and z-values of the four vertices
+  # of this cell in real space. 
+  x := array(0..7):
+  y := array(0..7):
+  z := array(0..7):
+  tphi[0] := (1-xi)*(1-eta)*(1-zeta):
+  tphi[1] := xi*(1-eta)*(1-zeta):
+  tphi[2] := xi*eta*(1-zeta):
+  tphi[3] := (1-xi)*eta*(1-zeta):
+  tphi[4] := (1-xi)*(1-eta)*zeta:
+  tphi[5] := xi*(1-eta)*zeta:
+  tphi[6] := xi*eta*zeta:
+  tphi[7] := (1-xi)*eta*zeta:
+  x_real := sum(x[s]*tphi[s], s=0..7):
+  y_real := sum(y[s]*tphi[s], s=0..7):
+  z_real := sum(z[s]*tphi[s], s=0..7):
+  with (linalg):
+  J := matrix(3,3, [[diff(x_real, xi), diff(x_real, eta), diff(x_real, zeta)],
+                    [diff(y_real, xi), diff(y_real, eta), diff(y_real, zeta)],
+                   [diff(z_real, xi), diff(z_real, eta), diff(z_real, zeta)]]): 
+  detJ := det (J):
+
+  measure := simplify ( int ( int ( int (detJ, xi=0..1), eta=0..1), zeta=0..1)):
+
+  xs := simplify (1/measure * int ( int ( int (x_real * detJ, xi=0..1), eta=0..1), zeta=0..1)):
+  ys := simplify (1/measure * int ( int ( int (y_real * detJ, xi=0..1), eta=0..1), zeta=0..1)):
+  zs := simplify (1/measure * int ( int ( int (z_real * detJ, xi=0..1), eta=0..1), zeta=0..1)):
+
+  readlib(C):
+
+  C(array(1..3, [xs, ys, zs]));
+*/
+
+  const double x[8] = { vertex(0)(0),
+                       vertex(1)(0),
+                       vertex(2)(0),
+                       vertex(3)(0),
+                       vertex(4)(0),
+                       vertex(5)(0),
+                       vertex(6)(0),
+                       vertex(7)(0)   };
+  const double y[8] = { vertex(0)(1),
+                       vertex(1)(1),
+                       vertex(2)(1),
+                       vertex(3)(1),
+                       vertex(4)(1),
+                       vertex(5)(1),
+                       vertex(6)(1),
+                       vertex(7)(1)  };
+  const double z[8] = { vertex(0)(2),
+                       vertex(1)(2),
+                       vertex(2)(2),
+                       vertex(3)(2),
+                       vertex(4)(2),
+                       vertex(5)(2),
+                       vertex(6)(2),
+                       vertex(7)(2)  };
+
+  double s1, s2, s3, s4, s5, s6, s7, s8;
+  
+  s1 = 1.0/6.0;
+  s8 = -x[2]*x[2]*y[0]*z[3]-2.0*z[6]*x[7]*x[7]*y[4]-z[5]*x[7]*x[7]*y[4]-z
+[6]*x[7]*x[7]*y[5]+2.0*y[6]*x[7]*x[7]*z[4]-z[5]*x[6]*x[6]*y[4]+x[6]*x[6]*y[4]*z
+[7]-z[1]*x[0]*x[0]*y[2]-x[6]*x[6]*y[7]*z[4]+2.0*x[6]*x[6]*y[5]*z[7]-2.0*x[6]*x
+[6]*y[7]*z[5]+y[5]*x[6]*x[6]*z[4]+2.0*x[5]*x[5]*y[4]*z[6]+x[0]*x[0]*y[7]*z[4]
+-2.0*x[5]*x[5]*y[6]*z[4];
+  s7 = s8-y[6]*x[5]*x[5]*z[7]+z[6]*x[5]*x[5]*y[7]-y[1]*x[0]*x[0]*z[5]+x[7]*
+z[5]*x[4]*y[7]-x[7]*y[6]*x[5]*z[7]-2.0*x[7]*x[6]*y[7]*z[4]+2.0*x[7]*x[6]*y[4]*z
+[7]-x[7]*x[5]*y[7]*z[4]-2.0*x[7]*y[6]*x[4]*z[7]-x[7]*y[5]*x[4]*z[7]+x[2]*x[2]*y
+[3]*z[0]-x[7]*x[6]*y[7]*z[5]+x[7]*x[6]*y[5]*z[7]+2.0*x[1]*x[1]*y[0]*z[5]+x[7]*z
+[6]*x[5]*y[7];
+  s8 = -2.0*x[1]*x[1]*y[5]*z[0]+z[1]*x[0]*x[0]*y[5]+2.0*x[2]*x[2]*y[3]*z[1]
+-z[5]*x[4]*x[4]*y[1]+y[5]*x[4]*x[4]*z[1]-2.0*x[5]*x[5]*y[4]*z[1]+2.0*x[5]*x[5]*
+y[1]*z[4]-2.0*x[2]*x[2]*y[1]*z[3]-y[1]*x[2]*x[2]*z[0]+x[7]*y[2]*x[3]*z[7]+x[7]*
+z[2]*x[6]*y[3]+2.0*x[7]*z[6]*x[4]*y[7]+z[5]*x[1]*x[1]*y[4]+z[1]*x[2]*x[2]*y[0]
+-2.0*y[0]*x[3]*x[3]*z[7];
+  s6 = s8+2.0*z[0]*x[3]*x[3]*y[7]-x[7]*x[2]*y[3]*z[7]-x[7]*z[2]*x[3]*y[7]+x
+[7]*x[2]*y[7]*z[3]-x[7]*y[2]*x[6]*z[3]+x[4]*x[5]*y[1]*z[4]-x[4]*x[5]*y[4]*z[1]+
+x[4]*z[5]*x[1]*y[4]-x[4]*y[5]*x[1]*z[4]-2.0*x[5]*z[5]*x[4]*y[1]-2.0*x[5]*y[5]*x
+[1]*z[4]+2.0*x[5]*z[5]*x[1]*y[4]+2.0*x[5]*y[5]*x[4]*z[1]-x[6]*z[5]*x[7]*y[4]-z
+[2]*x[3]*x[3]*y[6]+s7;
+  s8 = -2.0*x[6]*z[6]*x[7]*y[5]-x[6]*y[6]*x[4]*z[7]+y[2]*x[3]*x[3]*z[6]+x
+[6]*y[6]*x[7]*z[4]+2.0*y[2]*x[3]*x[3]*z[7]+x[0]*x[1]*y[0]*z[5]+x[0]*y[1]*x[5]*z
+[0]-x[0]*z[1]*x[5]*y[0]-2.0*z[2]*x[3]*x[3]*y[7]+2.0*x[6]*z[6]*x[5]*y[7]-x[0]*x
+[1]*y[5]*z[0]-x[6]*y[5]*x[4]*z[6]-2.0*x[3]*z[0]*x[7]*y[3]-x[6]*z[6]*x[7]*y[4]
+-2.0*x[1]*z[1]*x[5]*y[0];
+  s7 = s8+2.0*x[1]*y[1]*x[5]*z[0]+2.0*x[1]*z[1]*x[0]*y[5]+2.0*x[3]*y[0]*x
+[7]*z[3]+2.0*x[3]*x[0]*y[3]*z[7]-2.0*x[3]*x[0]*y[7]*z[3]-2.0*x[1]*y[1]*x[0]*z
+[5]-2.0*x[6]*y[6]*x[5]*z[7]+s6-y[5]*x[1]*x[1]*z[4]+x[6]*z[6]*x[4]*y[7]-2.0*x[2]
+*y[2]*x[3]*z[1]+x[6]*z[5]*x[4]*y[6]+x[6]*x[5]*y[4]*z[6]-y[6]*x[7]*x[7]*z[2]-x
+[6]*x[5]*y[6]*z[4];
+  s8 = x[3]*x[3]*y[7]*z[4]-2.0*y[6]*x[7]*x[7]*z[3]+z[6]*x[7]*x[7]*y[2]+2.0*
+z[6]*x[7]*x[7]*y[3]+2.0*y[1]*x[0]*x[0]*z[3]+2.0*x[0]*x[1]*y[3]*z[0]-2.0*x[0]*y
+[0]*x[3]*z[4]-2.0*x[0]*z[1]*x[4]*y[0]-2.0*x[0]*y[1]*x[3]*z[0]+2.0*x[0]*y[0]*x
+[4]*z[3]-2.0*x[0]*z[0]*x[4]*y[3]+2.0*x[0]*x[1]*y[0]*z[4]+2.0*x[0]*z[1]*x[3]*y
+[0]-2.0*x[0]*x[1]*y[0]*z[3]-2.0*x[0]*x[1]*y[4]*z[0]+2.0*x[0]*y[1]*x[4]*z[0];
+  s5 = s8+2.0*x[0]*z[0]*x[3]*y[4]+x[1]*y[1]*x[0]*z[3]-x[1]*z[1]*x[4]*y[0]-x
+[1]*y[1]*x[0]*z[4]+x[1]*z[1]*x[0]*y[4]-x[1]*y[1]*x[3]*z[0]-x[1]*z[1]*x[0]*y[3]-
+x[0]*z[5]*x[4]*y[1]+x[0]*y[5]*x[4]*z[1]-2.0*x[4]*x[0]*y[4]*z[7]-2.0*x[4]*y[5]*x
+[0]*z[4]+2.0*x[4]*z[5]*x[0]*y[4]-2.0*x[4]*x[5]*y[4]*z[0]-2.0*x[4]*y[0]*x[7]*z
+[4]-x[5]*y[5]*x[0]*z[4]+s7;
+  s8 = x[5]*z[5]*x[0]*y[4]-x[5]*z[5]*x[4]*y[0]+x[1]*z[5]*x[0]*y[4]+x[5]*y
+[5]*x[4]*z[0]-x[0]*y[0]*x[7]*z[4]-x[0]*z[5]*x[4]*y[0]-x[1]*y[5]*x[0]*z[4]+x[0]*
+z[0]*x[7]*y[4]+x[0]*y[5]*x[4]*z[0]-x[0]*z[0]*x[4]*y[7]+x[0]*x[5]*y[0]*z[4]+x[0]
+*y[0]*x[4]*z[7]-x[0]*x[5]*y[4]*z[0]-x[3]*x[3]*y[4]*z[7]+2.0*x[2]*z[2]*x[3]*y[1]
+;
+  s7 = s8-x[5]*x[5]*y[4]*z[0]+2.0*y[5]*x[4]*x[4]*z[0]-2.0*z[0]*x[4]*x[4]*y
+[7]+2.0*y[0]*x[4]*x[4]*z[7]-2.0*z[5]*x[4]*x[4]*y[0]+x[5]*x[5]*y[4]*z[7]-x[5]*x
+[5]*y[7]*z[4]-2.0*y[5]*x[4]*x[4]*z[7]+2.0*z[5]*x[4]*x[4]*y[7]-x[0]*x[0]*y[7]*z
+[3]+y[2]*x[0]*x[0]*z[3]+x[0]*x[0]*y[3]*z[7]-x[5]*x[1]*y[4]*z[0]+x[5]*y[1]*x[4]*
+z[0]-x[4]*y[0]*x[3]*z[4];
+  s8 = -x[4]*y[1]*x[0]*z[4]+x[4]*z[1]*x[0]*y[4]+x[4]*x[0]*y[3]*z[4]-x[4]*x
+[0]*y[4]*z[3]+x[4]*x[1]*y[0]*z[4]-x[4]*x[1]*y[4]*z[0]+x[4]*z[0]*x[3]*y[4]+x[5]*
+x[1]*y[0]*z[4]+x[1]*z[1]*x[3]*y[0]+x[1]*y[1]*x[4]*z[0]-x[5]*z[1]*x[4]*y[0]-2.0*
+y[1]*x[0]*x[0]*z[4]+2.0*z[1]*x[0]*x[0]*y[4]+2.0*x[0]*x[0]*y[3]*z[4]-2.0*z[1]*x
+[0]*x[0]*y[3];
+  s6 = s8-2.0*x[0]*x[0]*y[4]*z[3]+x[1]*x[1]*y[3]*z[0]+x[1]*x[1]*y[0]*z[4]-x
+[1]*x[1]*y[0]*z[3]-x[1]*x[1]*y[4]*z[0]-z[1]*x[4]*x[4]*y[0]+y[0]*x[4]*x[4]*z[3]-
+z[0]*x[4]*x[4]*y[3]+y[1]*x[4]*x[4]*z[0]-x[0]*x[0]*y[4]*z[7]-y[5]*x[0]*x[0]*z[4]
++z[5]*x[0]*x[0]*y[4]+x[5]*x[5]*y[0]*z[4]-x[0]*y[0]*x[3]*z[7]+x[0]*z[0]*x[3]*y
+[7]+s7;
+  s8 = s6+x[0]*x[2]*y[3]*z[0]-x[0]*x[2]*y[0]*z[3]+x[0]*y[0]*x[7]*z[3]-x[0]*
+y[2]*x[3]*z[0]+x[0]*z[2]*x[3]*y[0]-x[0]*z[0]*x[7]*y[3]+x[1]*x[2]*y[3]*z[0]-z[2]
+*x[0]*x[0]*y[3]+x[3]*z[2]*x[6]*y[3]-x[3]*x[2]*y[3]*z[6]+x[3]*x[2]*y[6]*z[3]-x
+[3]*y[2]*x[6]*z[3]-2.0*x[3]*y[2]*x[7]*z[3]+2.0*x[3]*z[2]*x[7]*y[3];
+  s7 = s8+2.0*x[4]*y[5]*x[7]*z[4]+2.0*x[4]*x[5]*y[4]*z[7]-2.0*x[4]*z[5]*x
+[7]*y[4]-2.0*x[4]*x[5]*y[7]*z[4]+x[5]*y[5]*x[7]*z[4]-x[5]*z[5]*x[7]*y[4]-x[5]*y
+[5]*x[4]*z[7]+x[5]*z[5]*x[4]*y[7]+2.0*x[3]*x[2]*y[7]*z[3]-2.0*x[2]*z[2]*x[1]*y
+[3]+2.0*x[4]*z[0]*x[7]*y[4]+2.0*x[4]*x[0]*y[7]*z[4]+2.0*x[4]*x[5]*y[0]*z[4]-x
+[7]*x[6]*y[2]*z[7]-2.0*x[3]*x[2]*y[3]*z[7]-x[0]*x[4]*y[7]*z[3];
+  s8 = x[0]*x[3]*y[7]*z[4]-x[0]*x[3]*y[4]*z[7]+x[0]*x[4]*y[3]*z[7]-2.0*x[7]
+*z[6]*x[3]*y[7]+x[3]*x[7]*y[4]*z[3]-x[3]*x[4]*y[7]*z[3]-x[3]*x[7]*y[3]*z[4]+x
+[3]*x[4]*y[3]*z[7]+2.0*x[2]*y[2]*x[1]*z[3]+y[6]*x[3]*x[3]*z[7]-z[6]*x[3]*x[3]*y
+[7]-x[1]*z[5]*x[4]*y[1]-x[1]*x[5]*y[4]*z[1]-x[1]*z[2]*x[0]*y[3]-x[1]*x[2]*y[0]*
+z[3]+x[1]*y[2]*x[0]*z[3];
+  s4 = s8+x[1]*x[5]*y[1]*z[4]+x[1]*y[5]*x[4]*z[1]+x[4]*y[0]*x[7]*z[3]-x[4]*
+z[0]*x[7]*y[3]-x[4]*x[4]*y[7]*z[3]+x[4]*x[4]*y[3]*z[7]+x[3]*z[6]*x[7]*y[3]-x[3]
+*x[6]*y[3]*z[7]+x[3]*x[6]*y[7]*z[3]-x[3]*z[6]*x[2]*y[7]-x[3]*y[6]*x[7]*z[3]+x
+[3]*z[6]*x[7]*y[2]+x[3]*y[6]*x[2]*z[7]+2.0*x[5]*z[5]*x[4]*y[6]+s5+s7;
+  s8 = s4-2.0*x[5]*z[5]*x[6]*y[4]-x[5]*z[6]*x[7]*y[5]+x[5]*x[6]*y[5]*z[7]-x
+[5]*x[6]*y[7]*z[5]-2.0*x[5]*y[5]*x[4]*z[6]+2.0*x[5]*y[5]*x[6]*z[4]-x[3]*y[6]*x
+[7]*z[2]+x[4]*x[7]*y[4]*z[3]+x[4]*x[3]*y[7]*z[4]-x[4]*x[7]*y[3]*z[4]-x[4]*x[3]*
+y[4]*z[7]-z[1]*x[5]*x[5]*y[0]+y[1]*x[5]*x[5]*z[0]+x[4]*y[6]*x[7]*z[4];
+  s7 = s8-x[4]*x[6]*y[7]*z[4]+x[4]*x[6]*y[4]*z[7]-x[4]*z[6]*x[7]*y[4]-x[5]*
+y[6]*x[4]*z[7]-x[5]*x[6]*y[7]*z[4]+x[5]*x[6]*y[4]*z[7]+x[5]*z[6]*x[4]*y[7]-y[6]
+*x[4]*x[4]*z[7]+z[6]*x[4]*x[4]*y[7]+x[7]*x[5]*y[4]*z[7]-y[2]*x[7]*x[7]*z[3]+z
+[2]*x[7]*x[7]*y[3]-y[0]*x[3]*x[3]*z[4]-y[1]*x[3]*x[3]*z[0]+z[1]*x[3]*x[3]*y[0];
+  s8 = z[0]*x[3]*x[3]*y[4]-x[2]*y[1]*x[3]*z[0]+x[2]*z[1]*x[3]*y[0]+x[3]*y
+[1]*x[0]*z[3]+x[3]*x[1]*y[3]*z[0]+x[3]*x[0]*y[3]*z[4]-x[3]*z[1]*x[0]*y[3]-x[3]*
+x[0]*y[4]*z[3]+x[3]*y[0]*x[4]*z[3]-x[3]*z[0]*x[4]*y[3]-x[3]*x[1]*y[0]*z[3]+x[3]
+*z[0]*x[7]*y[4]-x[3]*y[0]*x[7]*z[4]+z[0]*x[7]*x[7]*y[4]-y[0]*x[7]*x[7]*z[4];
+  s6 = s8+y[1]*x[0]*x[0]*z[2]-2.0*y[2]*x[3]*x[3]*z[0]+2.0*z[2]*x[3]*x[3]*y
+[0]-2.0*x[1]*x[1]*y[0]*z[2]+2.0*x[1]*x[1]*y[2]*z[0]-y[2]*x[3]*x[3]*z[1]+z[2]*x
+[3]*x[3]*y[1]-y[5]*x[4]*x[4]*z[6]+z[5]*x[4]*x[4]*y[6]+x[7]*x[0]*y[7]*z[4]-x[7]*
+z[0]*x[4]*y[7]-x[7]*x[0]*y[4]*z[7]+x[7]*y[0]*x[4]*z[7]-x[0]*x[1]*y[0]*z[2]+x[0]
+*z[1]*x[2]*y[0]+s7;
+  s8 = s6+x[0]*x[1]*y[2]*z[0]-x[0]*y[1]*x[2]*z[0]-x[3]*z[1]*x[0]*y[2]+2.0*x
+[3]*x[2]*y[3]*z[0]+y[0]*x[7]*x[7]*z[3]-z[0]*x[7]*x[7]*y[3]-2.0*x[3]*z[2]*x[0]*y
+[3]-2.0*x[3]*x[2]*y[0]*z[3]+2.0*x[3]*y[2]*x[0]*z[3]+x[3]*x[2]*y[3]*z[1]-x[3]*x
+[2]*y[1]*z[3]-x[5]*y[1]*x[0]*z[5]+x[3]*y[1]*x[0]*z[2]+x[4]*y[6]*x[7]*z[5];
+  s7 = s8-x[5]*x[1]*y[5]*z[0]+2.0*x[1]*z[1]*x[2]*y[0]-2.0*x[1]*z[1]*x[0]*y
+[2]+x[1]*x[2]*y[3]*z[1]-x[1]*x[2]*y[1]*z[3]+2.0*x[1]*y[1]*x[0]*z[2]-2.0*x[1]*y
+[1]*x[2]*z[0]-z[2]*x[1]*x[1]*y[3]+y[2]*x[1]*x[1]*z[3]+y[5]*x[7]*x[7]*z[4]+y[6]*
+x[7]*x[7]*z[5]+x[7]*x[6]*y[7]*z[2]+x[7]*y[6]*x[2]*z[7]-x[7]*z[6]*x[2]*y[7]-2.0*
+x[7]*x[6]*y[3]*z[7];
+  s8 = s7+2.0*x[7]*x[6]*y[7]*z[3]+2.0*x[7]*y[6]*x[3]*z[7]-x[3]*z[2]*x[1]*y
+[3]+x[3]*y[2]*x[1]*z[3]+x[5]*x[1]*y[0]*z[5]+x[4]*y[5]*x[6]*z[4]+x[5]*z[1]*x[0]*
+y[5]-x[4]*z[6]*x[7]*y[5]-x[4]*x[5]*y[6]*z[4]+x[4]*x[5]*y[4]*z[6]-x[4]*z[5]*x[6]
+*y[4]-x[1]*y[2]*x[3]*z[1]+x[1]*z[2]*x[3]*y[1]-x[2]*x[1]*y[0]*z[2]-x[2]*z[1]*x
+[0]*y[2];
+  s5 = s8+x[2]*x[1]*y[2]*z[0]-x[2]*z[2]*x[0]*y[3]+x[2]*y[2]*x[0]*z[3]-x[2]*
+y[2]*x[3]*z[0]+x[2]*z[2]*x[3]*y[0]+x[2]*y[1]*x[0]*z[2]+x[5]*y[6]*x[7]*z[5]+x[6]
+*y[5]*x[7]*z[4]+2.0*x[6]*y[6]*x[7]*z[5]-x[7]*y[0]*x[3]*z[7]+x[7]*z[0]*x[3]*y[7]
+-x[7]*x[0]*y[7]*z[3]+x[7]*x[0]*y[3]*z[7]+2.0*x[7]*x[7]*y[4]*z[3]-2.0*x[7]*x[7]*
+y[3]*z[4]-2.0*x[1]*x[1]*y[2]*z[5];
+  s8 = s5-2.0*x[7]*x[4]*y[7]*z[3]+2.0*x[7]*x[3]*y[7]*z[4]-2.0*x[7]*x[3]*y
+[4]*z[7]+2.0*x[7]*x[4]*y[3]*z[7]+2.0*x[1]*x[1]*y[5]*z[2]-x[1]*x[1]*y[2]*z[6]+x
+[1]*x[1]*y[6]*z[2]+z[1]*x[5]*x[5]*y[2]-y[1]*x[5]*x[5]*z[2]-x[1]*x[1]*y[6]*z[5]+
+x[1]*x[1]*y[5]*z[6]+x[5]*x[5]*y[6]*z[2]-x[5]*x[5]*y[2]*z[6]-2.0*y[1]*x[5]*x[5]*
+z[6];
+  s7 = s8+2.0*z[1]*x[5]*x[5]*y[6]+2.0*x[1]*z[1]*x[5]*y[2]+2.0*x[1]*y[1]*x
+[2]*z[5]-2.0*x[1]*z[1]*x[2]*y[5]-2.0*x[1]*y[1]*x[5]*z[2]-x[1]*y[1]*x[6]*z[2]-x
+[1]*z[1]*x[2]*y[6]+x[1]*z[1]*x[6]*y[2]+x[1]*y[1]*x[2]*z[6]-x[5]*x[1]*y[2]*z[5]+
+x[5]*y[1]*x[2]*z[5]-x[5]*z[1]*x[2]*y[5]+x[5]*x[1]*y[5]*z[2]-x[5]*y[1]*x[6]*z[2]
+-x[5]*x[1]*y[2]*z[6];
+  s8 = s7+x[5]*x[1]*y[6]*z[2]+x[5]*z[1]*x[6]*y[2]+x[1]*x[2]*y[5]*z[6]-x[1]*
+x[2]*y[6]*z[5]-x[1]*z[1]*x[6]*y[5]-x[1]*y[1]*x[5]*z[6]+x[1]*z[1]*x[5]*y[6]+x[1]
+*y[1]*x[6]*z[5]-x[5]*x[6]*y[5]*z[2]+x[5]*x[2]*y[5]*z[6]-x[5]*x[2]*y[6]*z[5]+x
+[5]*x[6]*y[2]*z[5]-2.0*x[5]*z[1]*x[6]*y[5]-2.0*x[5]*x[1]*y[6]*z[5]+2.0*x[5]*x
+[1]*y[5]*z[6];
+  s6 = s8+2.0*x[5]*y[1]*x[6]*z[5]+2.0*x[2]*x[1]*y[6]*z[2]+2.0*x[2]*z[1]*x
+[6]*y[2]-2.0*x[2]*x[1]*y[2]*z[6]+x[2]*x[5]*y[6]*z[2]+x[2]*x[6]*y[2]*z[5]-x[2]*x
+[5]*y[2]*z[6]+y[1]*x[2]*x[2]*z[5]-z[1]*x[2]*x[2]*y[5]-2.0*x[2]*y[1]*x[6]*z[2]-x
+[2]*x[6]*y[5]*z[2]-2.0*z[1]*x[2]*x[2]*y[6]+x[2]*x[2]*y[5]*z[6]-x[2]*x[2]*y[6]*z
+[5]+2.0*y[1]*x[2]*x[2]*z[6]+x[2]*z[1]*x[5]*y[2];
+  s8 = s6-x[2]*x[1]*y[2]*z[5]+x[2]*x[1]*y[5]*z[2]-x[2]*y[1]*x[5]*z[2]+x[6]*
+y[1]*x[2]*z[5]-x[6]*z[1]*x[2]*y[5]-z[1]*x[6]*x[6]*y[5]+y[1]*x[6]*x[6]*z[5]-y[1]
+*x[6]*x[6]*z[2]-2.0*x[6]*x[6]*y[5]*z[2]+2.0*x[6]*x[6]*y[2]*z[5]+z[1]*x[6]*x[6]*
+y[2]-x[6]*x[1]*y[6]*z[5]-x[6]*y[1]*x[5]*z[6]+x[6]*x[1]*y[5]*z[6];
+  s7 = s8+x[6]*z[1]*x[5]*y[6]-x[6]*z[1]*x[2]*y[6]-x[6]*x[1]*y[2]*z[6]+2.0*x
+[6]*x[5]*y[6]*z[2]+2.0*x[6]*x[2]*y[5]*z[6]-2.0*x[6]*x[2]*y[6]*z[5]-2.0*x[6]*x
+[5]*y[2]*z[6]+x[6]*x[1]*y[6]*z[2]+x[6]*y[1]*x[2]*z[6]-x[2]*x[2]*y[3]*z[7]+x[2]*
+x[2]*y[7]*z[3]-x[2]*z[2]*x[3]*y[7]-x[2]*y[2]*x[7]*z[3]+x[2]*z[2]*x[7]*y[3]+x[2]
+*y[2]*x[3]*z[7]-x[6]*x[6]*y[3]*z[7];
+  s8 = s7+x[6]*x[6]*y[7]*z[3]-x[6]*x[2]*y[3]*z[7]+x[6]*x[2]*y[7]*z[3]-x[6]*
+y[6]*x[7]*z[3]+x[6]*y[6]*x[3]*z[7]-x[6]*z[6]*x[3]*y[7]+x[6]*z[6]*x[7]*y[3]+y[6]
+*x[2]*x[2]*z[7]-z[6]*x[2]*x[2]*y[7]+2.0*x[2]*x[2]*y[6]*z[3]-x[2]*y[6]*x[7]*z[2]
+-2.0*x[2]*y[2]*x[6]*z[3]-2.0*x[2]*x[2]*y[3]*z[6]+2.0*x[2]*y[2]*x[3]*z[6]-x[2]*x
+[6]*y[2]*z[7];
+  s3 = s8+x[2]*x[6]*y[7]*z[2]+x[2]*z[6]*x[7]*y[2]+2.0*x[2]*z[2]*x[6]*y[3]
+-2.0*x[2]*z[2]*x[3]*y[6]-y[2]*x[6]*x[6]*z[3]-2.0*x[6]*x[6]*y[2]*z[7]+2.0*x[6]*x
+[6]*y[7]*z[2]+z[2]*x[6]*x[6]*y[3]-2.0*x[6]*y[6]*x[7]*z[2]+x[6]*y[2]*x[3]*z[6]-x
+[6]*x[2]*y[3]*z[6]+2.0*x[6]*z[6]*x[7]*y[2]+2.0*x[6]*y[6]*x[2]*z[7]-2.0*x[6]*z
+[6]*x[2]*y[7]+x[6]*x[2]*y[6]*z[3]-x[6]*z[2]*x[3]*y[6];
+  s8 = y[1]*x[0]*z[3]+x[1]*y[3]*z[0]-y[0]*x[3]*z[7]-x[1]*y[5]*z[0]-y[0]*x
+[3]*z[4]-x[1]*y[0]*z[2]+z[1]*x[2]*y[0]-y[1]*x[0]*z[5]-z[1]*x[0]*y[2]-y[1]*x[0]*
+z[4]+z[1]*x[5]*y[2]+z[0]*x[7]*y[4]+z[0]*x[3]*y[7]+z[1]*x[0]*y[4]-x[1]*y[2]*z[5]
++x[2]*y[3]*z[0]+y[1]*x[2]*z[5]-x[2]*y[3]*z[7];
+  s7 = s8-z[1]*x[2]*y[5]-y[1]*x[3]*z[0]-x[0]*y[7]*z[3]-z[1]*x[0]*y[3]+y[5]*
+x[4]*z[0]-x[0]*y[4]*z[3]+y[5]*x[7]*z[4]-z[0]*x[4]*y[3]+x[1]*y[0]*z[4]-z[2]*x[3]
+*y[7]-y[6]*x[7]*z[2]+x[1]*y[5]*z[2]+y[6]*x[7]*z[5]+x[0]*y[7]*z[4]+x[1]*y[2]*z
+[0]-z[1]*x[4]*y[0]-z[0]*x[4]*y[7]-z[2]*x[0]*y[3];
+  s8 = x[5]*y[0]*z[4]+z[1]*x[0]*y[5]-x[2]*y[0]*z[3]-z[1]*x[5]*y[0]+y[1]*x
+[5]*z[0]-x[1]*y[0]*z[3]-x[1]*y[4]*z[0]-y[1]*x[5]*z[2]+x[2]*y[7]*z[3]+y[0]*x[4]*
+z[3]-x[0]*y[4]*z[7]+x[1]*y[0]*z[5]-y[1]*x[6]*z[2]-y[2]*x[6]*z[3]+y[0]*x[7]*z[3]
+-y[2]*x[7]*z[3]+z[2]*x[7]*y[3]+y[2]*x[0]*z[3];
+  s6 = s8+y[2]*x[3]*z[7]-y[2]*x[3]*z[0]-x[6]*y[5]*z[2]-y[5]*x[0]*z[4]+z[2]*
+x[3]*y[0]+x[2]*y[3]*z[1]+x[0]*y[3]*z[7]-x[2]*y[1]*z[3]+y[1]*x[4]*z[0]+y[1]*x[0]
+*z[2]-z[1]*x[2]*y[6]+y[2]*x[3]*z[6]-y[1]*x[2]*z[0]+z[1]*x[3]*y[0]-x[1]*y[2]*z
+[6]-x[2]*y[3]*z[6]+x[0]*y[3]*z[4]+z[0]*x[3]*y[4]+s7;
+  s8 = x[5]*y[4]*z[7]+s6+y[5]*x[6]*z[4]-y[5]*x[4]*z[6]+z[6]*x[5]*y[7]-x[6]*
+y[2]*z[7]-x[6]*y[7]*z[5]+x[5]*y[6]*z[2]+x[6]*y[5]*z[7]+x[6]*y[7]*z[2]+y[6]*x[7]
+*z[4]-y[6]*x[4]*z[7]-y[6]*x[7]*z[3]+z[6]*x[7]*y[2]+x[2]*y[5]*z[6]-x[2]*y[6]*z
+[5]+y[6]*x[2]*z[7]+x[6]*y[2]*z[5];
+  s7 = s8-x[5]*y[2]*z[6]-z[6]*x[7]*y[5]-z[5]*x[7]*y[4]+z[5]*x[0]*y[4]-y[5]*
+x[4]*z[7]+y[0]*x[4]*z[7]-z[6]*x[2]*y[7]-x[5]*y[4]*z[0]-x[5]*y[7]*z[4]-y[0]*x[7]
+*z[4]+y[5]*x[4]*z[1]-x[6]*y[7]*z[4]+x[7]*y[4]*z[3]-x[4]*y[7]*z[3]+x[3]*y[7]*z
+[4]-x[7]*y[3]*z[4]-x[6]*y[3]*z[7]+x[6]*y[4]*z[7];
+  s8 = -x[3]*y[4]*z[7]+x[4]*y[3]*z[7]-z[6]*x[7]*y[4]-z[1]*x[6]*y[5]+x[6]*y
+[7]*z[3]-x[1]*y[6]*z[5]-y[1]*x[5]*z[6]+z[5]*x[4]*y[7]-z[5]*x[4]*y[0]+x[1]*y[5]*
+z[6]-y[6]*x[5]*z[7]-y[2]*x[3]*z[1]+z[1]*x[5]*y[6]-y[5]*x[1]*z[4]+z[6]*x[4]*y[7]
++x[5]*y[1]*z[4]-x[5]*y[6]*z[4]+y[6]*x[3]*z[7]-x[5]*y[4]*z[1];
+  s5 = s8+x[5]*y[4]*z[6]+z[5]*x[1]*y[4]+y[1]*x[6]*z[5]-z[6]*x[3]*y[7]+z[6]*
+x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
+*z[3]+z[2]*x[6]*y[3]+z[1]*x[6]*y[2]+z[2]*x[3]*y[1]-z[2]*x[1]*y[3]-z[2]*x[3]*y
+[6]+y[2]*x[1]*z[3]+y[1]*x[2]*z[6]-z[0]*x[7]*y[3]+s7;
+  s4 = 1/s5;
+  s2 = s3*s4;
+  const double unknown0 = s1*s2;
+  s1 = 1.0/6.0;
+  s8 = 2.0*x[1]*y[0]*y[0]*z[4]+x[5]*y[0]*y[0]*z[4]-x[1]*y[4]*y[4]*z[0]+z[1]
+*x[0]*y[4]*y[4]+x[1]*y[0]*y[0]*z[5]-z[1]*x[5]*y[0]*y[0]-2.0*z[1]*x[4]*y[0]*y[0]
++2.0*z[1]*x[3]*y[0]*y[0]+z[2]*x[3]*y[0]*y[0]+y[0]*y[0]*x[7]*z[3]+2.0*y[0]*y[0]*
+x[4]*z[3]-2.0*x[1]*y[0]*y[0]*z[3]-2.0*x[5]*y[4]*y[4]*z[0]+2.0*z[5]*x[0]*y[4]*y
+[4]+2.0*y[4]*y[5]*x[7]*z[4];
+  s7 = s8-x[3]*y[4]*y[4]*z[7]+x[7]*y[4]*y[4]*z[3]+z[0]*x[3]*y[4]*y[4]-2.0*x
+[0]*y[4]*y[4]*z[7]-y[1]*x[1]*y[4]*z[0]-x[0]*y[4]*y[4]*z[3]+2.0*z[0]*x[7]*y[4]*y
+[4]+y[4]*z[6]*x[4]*y[7]-y[0]*y[0]*x[7]*z[4]+y[0]*y[0]*x[4]*z[7]+2.0*y[4]*z[5]*x
+[4]*y[7]-2.0*y[4]*x[5]*y[7]*z[4]-y[4]*x[6]*y[7]*z[4]-y[4]*y[6]*x[4]*z[7]-2.0*y
+[4]*y[5]*x[4]*z[7];
+  s8 = y[4]*y[6]*x[7]*z[4]-y[7]*y[2]*x[7]*z[3]+y[7]*z[2]*x[7]*y[3]+y[7]*y
+[2]*x[3]*z[7]+2.0*x[5]*y[4]*y[4]*z[7]-y[7]*x[2]*y[3]*z[7]-y[0]*z[0]*x[4]*y[7]+z
+[6]*x[7]*y[3]*y[3]-y[0]*x[0]*y[4]*z[7]+y[0]*x[0]*y[7]*z[4]-2.0*x[2]*y[3]*y[3]*z
+[7]-z[5]*x[4]*y[0]*y[0]+y[0]*z[0]*x[7]*y[4]-2.0*z[6]*x[3]*y[7]*y[7]+z[1]*x[2]*y
+[0]*y[0];
+  s6 = s8+y[4]*y[0]*x[4]*z[3]-2.0*y[4]*z[0]*x[4]*y[7]+2.0*y[4]*x[0]*y[7]*z
+[4]-y[4]*z[0]*x[4]*y[3]-y[4]*x[0]*y[7]*z[3]+y[4]*z[0]*x[3]*y[7]-y[4]*y[0]*x[3]*
+z[4]+y[0]*x[4]*y[3]*z[7]-y[0]*x[7]*y[3]*z[4]-y[0]*x[3]*y[4]*z[7]+y[0]*x[7]*y[4]
+*z[3]+x[2]*y[7]*y[7]*z[3]-z[2]*x[3]*y[7]*y[7]-2.0*z[2]*x[0]*y[3]*y[3]+2.0*y[0]*
+z[1]*x[0]*y[4]+s7;
+  s8 = -2.0*y[0]*y[1]*x[0]*z[4]-y[0]*y[1]*x[0]*z[5]-y[0]*y[0]*x[3]*z[7]-z
+[1]*x[0]*y[3]*y[3]-y[0]*x[1]*y[5]*z[0]-2.0*z[0]*x[7]*y[3]*y[3]+x[0]*y[3]*y[3]*z
+[4]+2.0*x[0]*y[3]*y[3]*z[7]-z[0]*x[4]*y[3]*y[3]+2.0*x[2]*y[3]*y[3]*z[0]+x[1]*y
+[3]*y[3]*z[0]+2.0*y[7]*z[6]*x[7]*y[3]+2.0*y[7]*y[6]*x[3]*z[7]-2.0*y[7]*y[6]*x
+[7]*z[3]-2.0*y[7]*x[6]*y[3]*z[7];
+  s7 = s8+y[4]*x[4]*y[3]*z[7]-y[4]*x[4]*y[7]*z[3]+y[4]*x[3]*y[7]*z[4]-y[4]*
+x[7]*y[3]*z[4]+2.0*y[4]*y[0]*x[4]*z[7]-2.0*y[4]*y[0]*x[7]*z[4]+2.0*x[6]*y[7]*y
+[7]*z[3]+y[4]*x[0]*y[3]*z[4]+y[0]*y[1]*x[5]*z[0]+y[0]*z[1]*x[0]*y[5]-x[2]*y[0]*
+y[0]*z[3]+x[4]*y[3]*y[3]*z[7]-x[7]*y[3]*y[3]*z[4]-x[5]*y[4]*y[4]*z[1]+y[3]*z[0]
+*x[3]*y[4];
+  s8 = y[3]*y[0]*x[4]*z[3]+2.0*y[3]*y[0]*x[7]*z[3]+2.0*y[3]*y[2]*x[0]*z[3]
+-2.0*y[3]*y[2]*x[3]*z[0]+2.0*y[3]*z[2]*x[3]*y[0]+y[3]*z[1]*x[3]*y[0]-2.0*y[3]*x
+[2]*y[0]*z[3]-y[3]*x[1]*y[0]*z[3]-y[3]*y[1]*x[3]*z[0]-2.0*y[3]*x[0]*y[7]*z[3]-y
+[3]*x[0]*y[4]*z[3]-2.0*y[3]*y[0]*x[3]*z[7]-y[3]*y[0]*x[3]*z[4]+2.0*y[3]*z[0]*x
+[3]*y[7]+y[3]*y[1]*x[0]*z[3]+z[5]*x[1]*y[4]*y[4];
+  s5 = s8-2.0*y[0]*y[0]*x[3]*z[4]-2.0*y[0]*x[1]*y[4]*z[0]+y[3]*x[7]*y[4]*z
+[3]-y[3]*x[4]*y[7]*z[3]+y[3]*x[3]*y[7]*z[4]-y[3]*x[3]*y[4]*z[7]+y[3]*x[0]*y[7]*
+z[4]-y[3]*z[0]*x[4]*y[7]-2.0*y[4]*y[5]*x[0]*z[4]+s6+y[7]*x[0]*y[3]*z[7]-y[7]*z
+[0]*x[7]*y[3]+y[7]*y[0]*x[7]*z[3]-y[7]*y[0]*x[3]*z[7]+2.0*y[0]*y[1]*x[4]*z[0]+
+s7;
+  s8 = -2.0*y[7]*x[7]*y[3]*z[4]-2.0*y[7]*x[3]*y[4]*z[7]+2.0*y[7]*x[4]*y[3]*
+z[7]+y[7]*y[0]*x[4]*z[7]-y[7]*y[0]*x[7]*z[4]+2.0*y[7]*x[7]*y[4]*z[3]-y[7]*x[0]*
+y[4]*z[7]+y[7]*z[0]*x[7]*y[4]+z[5]*x[4]*y[7]*y[7]+2.0*z[6]*x[4]*y[7]*y[7]-x[5]*
+y[7]*y[7]*z[4]-2.0*x[6]*y[7]*y[7]*z[4]+2.0*y[7]*x[6]*y[4]*z[7]-2.0*y[7]*z[6]*x
+[7]*y[4]+2.0*y[7]*y[6]*x[7]*z[4];
+  s7 = s8-2.0*y[7]*y[6]*x[4]*z[7]-y[7]*z[5]*x[7]*y[4]-y[7]*y[5]*x[4]*z[7]-x
+[0]*y[7]*y[7]*z[3]+z[0]*x[3]*y[7]*y[7]+y[7]*x[5]*y[4]*z[7]+y[7]*y[5]*x[7]*z[4]-
+y[4]*x[1]*y[5]*z[0]-x[1]*y[0]*y[0]*z[2]-y[4]*y[5]*x[1]*z[4]-2.0*y[4]*z[5]*x[4]*
+y[0]-y[4]*y[1]*x[0]*z[4]+y[4]*y[5]*x[4]*z[1]+y[0]*z[0]*x[3]*y[7]-y[0]*z[1]*x[0]
+*y[2];
+  s8 = 2.0*y[0]*x[1]*y[3]*z[0]+y[4]*y[1]*x[4]*z[0]+2.0*y[0]*y[1]*x[0]*z[3]+
+y[4]*x[1]*y[0]*z[5]-y[4]*z[1]*x[5]*y[0]+y[4]*z[1]*x[0]*y[5]-y[4]*z[1]*x[4]*y[0]
++y[4]*x[1]*y[0]*z[4]-y[4]*z[5]*x[4]*y[1]+x[5]*y[4]*y[4]*z[6]-z[5]*x[6]*y[4]*y
+[4]+y[4]*x[5]*y[1]*z[4]-y[0]*z[2]*x[0]*y[3]+y[0]*y[5]*x[4]*z[0]+y[0]*x[1]*y[2]*
+z[0];
+  s6 = s8-2.0*y[0]*z[0]*x[4]*y[3]-2.0*y[0]*x[0]*y[4]*z[3]-2.0*y[0]*z[1]*x
+[0]*y[3]-y[0]*x[0]*y[7]*z[3]-2.0*y[0]*y[1]*x[3]*z[0]+y[0]*x[2]*y[3]*z[0]-y[0]*y
+[1]*x[2]*z[0]+y[0]*y[1]*x[0]*z[2]-y[0]*x[2]*y[1]*z[3]+y[0]*x[0]*y[3]*z[7]+y[0]*
+x[2]*y[3]*z[1]-y[0]*y[2]*x[3]*z[0]+y[0]*y[2]*x[0]*z[3]-y[0]*y[5]*x[0]*z[4]-y[4]
+*y[5]*x[4]*z[6]+s7;
+  s8 = s6+y[4]*z[6]*x[5]*y[7]-y[4]*x[6]*y[7]*z[5]+y[4]*x[6]*y[5]*z[7]-y[4]*
+z[6]*x[7]*y[5]-y[4]*x[5]*y[6]*z[4]+y[4]*z[5]*x[4]*y[6]+y[4]*y[5]*x[6]*z[4]-2.0*
+y[1]*y[1]*x[0]*z[5]+2.0*y[1]*y[1]*x[5]*z[0]-2.0*y[2]*y[2]*x[6]*z[3]+x[5]*y[1]*y
+[1]*z[4]-z[5]*x[4]*y[1]*y[1]-x[6]*y[2]*y[2]*z[7]+z[6]*x[7]*y[2]*y[2];
+  s7 = s8-x[1]*y[5]*y[5]*z[0]+z[1]*x[0]*y[5]*y[5]+y[1]*y[5]*x[4]*z[1]-y[1]*
+y[5]*x[1]*z[4]-2.0*y[2]*z[2]*x[3]*y[6]+2.0*y[1]*z[1]*x[0]*y[5]-2.0*y[1]*z[1]*x
+[5]*y[0]+2.0*y[1]*x[1]*y[0]*z[5]-y[2]*x[2]*y[3]*z[7]-y[2]*z[2]*x[3]*y[7]+y[2]*x
+[2]*y[7]*z[3]+y[2]*z[2]*x[7]*y[3]-2.0*y[2]*x[2]*y[3]*z[6]+2.0*y[2]*x[2]*y[6]*z
+[3]+2.0*y[2]*z[2]*x[6]*y[3]-y[3]*y[2]*x[6]*z[3];
+  s8 = y[3]*y[2]*x[3]*z[6]+y[3]*x[2]*y[6]*z[3]-y[3]*z[2]*x[3]*y[6]-y[2]*y
+[2]*x[7]*z[3]+2.0*y[2]*y[2]*x[3]*z[6]+y[2]*y[2]*x[3]*z[7]-2.0*y[1]*x[1]*y[5]*z
+[0]-x[2]*y[3]*y[3]*z[6]+z[2]*x[6]*y[3]*y[3]+2.0*y[6]*x[2]*y[5]*z[6]+2.0*y[6]*x
+[6]*y[2]*z[5]-2.0*y[6]*x[5]*y[2]*z[6]+2.0*y[3]*x[2]*y[7]*z[3]-2.0*y[3]*z[2]*x
+[3]*y[7]-y[0]*z[0]*x[7]*y[3]-y[0]*z[2]*x[1]*y[3];
+  s4 = s8-y[2]*y[6]*x[7]*z[2]+y[0]*z[2]*x[3]*y[1]+y[1]*z[5]*x[1]*y[4]-y[1]*
+x[5]*y[4]*z[1]+2.0*y[0]*z[0]*x[3]*y[4]+2.0*y[0]*x[0]*y[3]*z[4]+2.0*z[2]*x[7]*y
+[3]*y[3]-2.0*z[5]*x[7]*y[4]*y[4]+x[6]*y[4]*y[4]*z[7]-z[6]*x[7]*y[4]*y[4]+y[1]*y
+[1]*x[0]*z[3]+y[3]*x[6]*y[7]*z[2]-y[3]*z[6]*x[2]*y[7]+2.0*y[3]*y[2]*x[3]*z[7]+
+s5+s7;
+  s8 = s4+y[2]*x[6]*y[7]*z[2]-y[2]*y[6]*x[7]*z[3]+y[2]*y[6]*x[2]*z[7]-y[2]*
+z[6]*x[2]*y[7]-y[2]*x[6]*y[3]*z[7]+y[2]*y[6]*x[3]*z[7]+y[2]*z[6]*x[7]*y[3]-2.0*
+y[3]*y[2]*x[7]*z[3]-x[6]*y[3]*y[3]*z[7]+y[1]*y[1]*x[4]*z[0]-y[1]*y[1]*x[3]*z[0]
++x[2]*y[6]*y[6]*z[3]-z[2]*x[3]*y[6]*y[6]-y[1]*y[1]*x[0]*z[4];
+  s7 = s8+y[5]*x[1]*y[0]*z[5]+y[6]*x[2]*y[7]*z[3]-y[6]*y[2]*x[6]*z[3]+y[6]*
+y[2]*x[3]*z[6]-y[6]*x[2]*y[3]*z[6]+y[6]*z[2]*x[6]*y[3]-y[5]*y[1]*x[0]*z[5]-y[5]
+*z[1]*x[5]*y[0]+y[5]*y[1]*x[5]*z[0]-y[6]*z[2]*x[3]*y[7]-y[7]*y[6]*x[7]*z[2]+2.0
+*y[6]*y[6]*x[2]*z[7]+y[6]*y[6]*x[3]*z[7]+x[6]*y[7]*y[7]*z[2]-z[6]*x[2]*y[7]*y
+[7];
+  s8 = -x[2]*y[1]*y[1]*z[3]+2.0*y[1]*y[1]*x[0]*z[2]-2.0*y[1]*y[1]*x[2]*z[0]
++z[2]*x[3]*y[1]*y[1]-z[1]*x[0]*y[2]*y[2]+x[1]*y[2]*y[2]*z[0]+y[2]*y[2]*x[0]*z
+[3]-y[2]*y[2]*x[3]*z[0]-2.0*y[2]*y[2]*x[3]*z[1]+y[1]*x[1]*y[3]*z[0]-2.0*y[6]*y
+[6]*x[7]*z[2]+2.0*y[5]*y[5]*x[4]*z[1]-2.0*y[5]*y[5]*x[1]*z[4]-y[6]*y[6]*x[7]*z
+[3]-2.0*y[1]*x[1]*y[0]*z[2];
+  s6 = s8+2.0*y[1]*z[1]*x[2]*y[0]-2.0*y[1]*z[1]*x[0]*y[2]+2.0*y[1]*x[1]*y
+[2]*z[0]+y[1]*x[2]*y[3]*z[1]-y[1]*y[2]*x[3]*z[1]-y[1]*z[2]*x[1]*y[3]+y[1]*y[2]*
+x[1]*z[3]-y[2]*x[1]*y[0]*z[2]+y[2]*z[1]*x[2]*y[0]+y[2]*x[2]*y[3]*z[0]-y[7]*x[6]
+*y[2]*z[7]+y[7]*z[6]*x[7]*y[2]+y[7]*y[6]*x[2]*z[7]-y[6]*x[6]*y[3]*z[7]+y[6]*x
+[6]*y[7]*z[3]+s7;
+  s8 = s6-y[6]*z[6]*x[3]*y[7]+y[6]*z[6]*x[7]*y[3]+2.0*y[2]*y[2]*x[1]*z[3]+x
+[2]*y[3]*y[3]*z[1]-z[2]*x[1]*y[3]*y[3]+y[1]*x[1]*y[0]*z[4]+y[1]*z[1]*x[3]*y[0]-
+y[1]*x[1]*y[0]*z[3]+2.0*y[5]*x[5]*y[1]*z[4]-2.0*y[5]*x[5]*y[4]*z[1]+2.0*y[5]*z
+[5]*x[1]*y[4]-2.0*y[5]*z[5]*x[4]*y[1]-2.0*y[6]*x[6]*y[2]*z[7]+2.0*y[6]*x[6]*y
+[7]*z[2];
+  s7 = s8+2.0*y[6]*z[6]*x[7]*y[2]-2.0*y[6]*z[6]*x[2]*y[7]-y[1]*z[1]*x[4]*y
+[0]+y[1]*z[1]*x[0]*y[4]-y[1]*z[1]*x[0]*y[3]+2.0*y[6]*y[6]*x[7]*z[5]+2.0*y[5]*y
+[5]*x[6]*z[4]-2.0*y[5]*y[5]*x[4]*z[6]+x[6]*y[5]*y[5]*z[7]-y[3]*x[2]*y[1]*z[3]-y
+[3]*y[2]*x[3]*z[1]+y[3]*z[2]*x[3]*y[1]+y[3]*y[2]*x[1]*z[3]-y[2]*x[2]*y[0]*z[3]+
+y[2]*z[2]*x[3]*y[0];
+  s8 = s7+2.0*y[2]*x[2]*y[3]*z[1]-2.0*y[2]*x[2]*y[1]*z[3]+y[2]*y[1]*x[0]*z
+[2]-y[2]*y[1]*x[2]*z[0]+2.0*y[2]*z[2]*x[3]*y[1]-2.0*y[2]*z[2]*x[1]*y[3]-y[2]*z
+[2]*x[0]*y[3]+y[5]*z[6]*x[5]*y[7]-y[5]*x[6]*y[7]*z[5]-y[5]*y[6]*x[4]*z[7]-y[5]*
+y[6]*x[5]*z[7]-2.0*y[5]*x[5]*y[6]*z[4]+2.0*y[5]*x[5]*y[4]*z[6]-2.0*y[5]*z[5]*x
+[6]*y[4]+2.0*y[5]*z[5]*x[4]*y[6];
+  s5 = s8-y[1]*y[5]*x[0]*z[4]-z[6]*x[7]*y[5]*y[5]+y[6]*y[6]*x[7]*z[4]-y[6]*
+y[6]*x[4]*z[7]-2.0*y[6]*y[6]*x[5]*z[7]-x[5]*y[6]*y[6]*z[4]+z[5]*x[4]*y[6]*y[6]+
+z[6]*x[5]*y[7]*y[7]-x[6]*y[7]*y[7]*z[5]+y[1]*y[5]*x[4]*z[0]+y[7]*y[6]*x[7]*z[5]
++y[6]*y[5]*x[7]*z[4]+y[5]*y[6]*x[7]*z[5]+y[6]*y[5]*x[6]*z[4]-y[6]*y[5]*x[4]*z
+[6]+2.0*y[6]*z[6]*x[5]*y[7];
+  s8 = s5-2.0*y[6]*x[6]*y[7]*z[5]+2.0*y[6]*x[6]*y[5]*z[7]-2.0*y[6]*z[6]*x
+[7]*y[5]-y[6]*x[5]*y[7]*z[4]-y[6]*x[6]*y[7]*z[4]+y[6]*x[6]*y[4]*z[7]-y[6]*z[6]*
+x[7]*y[4]+y[6]*z[5]*x[4]*y[7]+y[6]*z[6]*x[4]*y[7]+y[6]*x[5]*y[4]*z[6]-y[6]*z[5]
+*x[6]*y[4]+y[7]*x[6]*y[5]*z[7]-y[7]*z[6]*x[7]*y[5]-2.0*y[6]*x[6]*y[5]*z[2];
+  s7 = s8-y[7]*y[6]*x[5]*z[7]+2.0*y[4]*y[5]*x[4]*z[0]+2.0*x[3]*y[7]*y[7]*z
+[4]-2.0*x[4]*y[7]*y[7]*z[3]-z[0]*x[4]*y[7]*y[7]+x[0]*y[7]*y[7]*z[4]-y[0]*z[5]*x
+[4]*y[1]+y[0]*x[5]*y[1]*z[4]-y[0]*x[5]*y[4]*z[0]+y[0]*z[5]*x[0]*y[4]-y[5]*y[5]*
+x[0]*z[4]+y[5]*y[5]*x[4]*z[0]+2.0*y[1]*y[1]*x[2]*z[5]-2.0*y[1]*y[1]*x[5]*z[2]+z
+[1]*x[5]*y[2]*y[2];
+  s8 = s7-x[1]*y[2]*y[2]*z[5]-y[5]*z[5]*x[4]*y[0]+y[5]*z[5]*x[0]*y[4]-y[5]*
+x[5]*y[4]*z[0]-y[2]*x[1]*y[6]*z[5]-y[2]*y[1]*x[5]*z[6]+y[2]*z[1]*x[5]*y[6]+y[2]
+*y[1]*x[6]*z[5]-y[1]*z[1]*x[6]*y[5]-y[1]*x[1]*y[6]*z[5]+y[1]*x[1]*y[5]*z[6]+y
+[1]*z[1]*x[5]*y[6]+y[5]*x[5]*y[0]*z[4]+y[2]*y[1]*x[2]*z[5]-y[2]*z[1]*x[2]*y[5];
+  s6 = s8+y[2]*x[1]*y[5]*z[2]-y[2]*y[1]*x[5]*z[2]-y[1]*y[1]*x[5]*z[6]+y[1]*
+y[1]*x[6]*z[5]-z[1]*x[2]*y[5]*y[5]+x[1]*y[5]*y[5]*z[2]+2.0*y[1]*z[1]*x[5]*y[2]
+-2.0*y[1]*x[1]*y[2]*z[5]-2.0*y[1]*z[1]*x[2]*y[5]+2.0*y[1]*x[1]*y[5]*z[2]-y[1]*y
+[1]*x[6]*z[2]+y[1]*y[1]*x[2]*z[6]-2.0*y[5]*x[1]*y[6]*z[5]-2.0*y[5]*y[1]*x[5]*z
+[6]+2.0*y[5]*z[1]*x[5]*y[6]+2.0*y[5]*y[1]*x[6]*z[5];
+  s8 = s6-y[6]*z[1]*x[6]*y[5]-y[6]*y[1]*x[5]*z[6]+y[6]*x[1]*y[5]*z[6]+y[6]*
+y[1]*x[6]*z[5]-2.0*z[1]*x[6]*y[5]*y[5]+2.0*x[1]*y[5]*y[5]*z[6]-x[1]*y[6]*y[6]*z
+[5]+z[1]*x[5]*y[6]*y[6]+y[5]*z[1]*x[5]*y[2]-y[5]*x[1]*y[2]*z[5]+y[5]*y[1]*x[2]*
+z[5]-y[5]*y[1]*x[5]*z[2]-y[6]*z[1]*x[2]*y[5]+y[6]*x[1]*y[5]*z[2];
+  s7 = s8-y[1]*z[1]*x[2]*y[6]-y[1]*x[1]*y[2]*z[6]+y[1]*x[1]*y[6]*z[2]+y[1]*
+z[1]*x[6]*y[2]+y[5]*x[5]*y[6]*z[2]-y[5]*x[2]*y[6]*z[5]+y[5]*x[6]*y[2]*z[5]-y[5]
+*x[5]*y[2]*z[6]-x[6]*y[5]*y[5]*z[2]+x[2]*y[5]*y[5]*z[6]-y[5]*y[5]*x[4]*z[7]+y
+[5]*y[5]*x[7]*z[4]-y[1]*x[6]*y[5]*z[2]+y[1]*x[2]*y[5]*z[6]-y[2]*x[6]*y[5]*z[2]
+-2.0*y[2]*y[1]*x[6]*z[2];
+  s8 = s7-2.0*y[2]*z[1]*x[2]*y[6]+2.0*y[2]*x[1]*y[6]*z[2]+2.0*y[2]*y[1]*x
+[2]*z[6]-2.0*x[1]*y[2]*y[2]*z[6]+2.0*z[1]*x[6]*y[2]*y[2]+x[6]*y[2]*y[2]*z[5]-x
+[5]*y[2]*y[2]*z[6]+2.0*x[5]*y[6]*y[6]*z[2]-2.0*x[2]*y[6]*y[6]*z[5]-z[1]*x[2]*y
+[6]*y[6]-y[6]*y[1]*x[6]*z[2]-y[6]*x[1]*y[2]*z[6]+y[6]*z[1]*x[6]*y[2]+y[6]*y[1]*
+x[2]*z[6]+x[1]*y[6]*y[6]*z[2];
+  s3 = s8+y[2]*x[5]*y[6]*z[2]+y[2]*x[2]*y[5]*z[6]-y[2]*x[2]*y[6]*z[5]+y[5]*
+z[5]*x[4]*y[7]+y[5]*x[5]*y[4]*z[7]-y[5]*z[5]*x[7]*y[4]-y[5]*x[5]*y[7]*z[4]+2.0*
+y[4]*x[5]*y[0]*z[4]-y[3]*z[6]*x[3]*y[7]+y[3]*y[6]*x[3]*z[7]+y[3]*x[6]*y[7]*z[3]
+-y[3]*y[6]*x[7]*z[3]-y[2]*y[1]*x[3]*z[0]-y[2]*z[1]*x[0]*y[3]+y[2]*y[1]*x[0]*z
+[3]+y[2]*x[1]*y[3]*z[0];
+  s8 = y[1]*x[0]*z[3]+x[1]*y[3]*z[0]-y[0]*x[3]*z[7]-x[1]*y[5]*z[0]-y[0]*x
+[3]*z[4]-x[1]*y[0]*z[2]+z[1]*x[2]*y[0]-y[1]*x[0]*z[5]-z[1]*x[0]*y[2]-y[1]*x[0]*
+z[4]+z[1]*x[5]*y[2]+z[0]*x[7]*y[4]+z[0]*x[3]*y[7]+z[1]*x[0]*y[4]-x[1]*y[2]*z[5]
++x[2]*y[3]*z[0]+y[1]*x[2]*z[5]-x[2]*y[3]*z[7];
+  s7 = s8-z[1]*x[2]*y[5]-y[1]*x[3]*z[0]-x[0]*y[7]*z[3]-z[1]*x[0]*y[3]+y[5]*
+x[4]*z[0]-x[0]*y[4]*z[3]+y[5]*x[7]*z[4]-z[0]*x[4]*y[3]+x[1]*y[0]*z[4]-z[2]*x[3]
+*y[7]-y[6]*x[7]*z[2]+x[1]*y[5]*z[2]+y[6]*x[7]*z[5]+x[0]*y[7]*z[4]+x[1]*y[2]*z
+[0]-z[1]*x[4]*y[0]-z[0]*x[4]*y[7]-z[2]*x[0]*y[3];
+  s8 = x[5]*y[0]*z[4]+z[1]*x[0]*y[5]-x[2]*y[0]*z[3]-z[1]*x[5]*y[0]+y[1]*x
+[5]*z[0]-x[1]*y[0]*z[3]-x[1]*y[4]*z[0]-y[1]*x[5]*z[2]+x[2]*y[7]*z[3]+y[0]*x[4]*
+z[3]-x[0]*y[4]*z[7]+x[1]*y[0]*z[5]-y[1]*x[6]*z[2]-y[2]*x[6]*z[3]+y[0]*x[7]*z[3]
+-y[2]*x[7]*z[3]+z[2]*x[7]*y[3]+y[2]*x[0]*z[3];
+  s6 = s8+y[2]*x[3]*z[7]-y[2]*x[3]*z[0]-x[6]*y[5]*z[2]-y[5]*x[0]*z[4]+z[2]*
+x[3]*y[0]+x[2]*y[3]*z[1]+x[0]*y[3]*z[7]-x[2]*y[1]*z[3]+y[1]*x[4]*z[0]+y[1]*x[0]
+*z[2]-z[1]*x[2]*y[6]+y[2]*x[3]*z[6]-y[1]*x[2]*z[0]+z[1]*x[3]*y[0]-x[1]*y[2]*z
+[6]-x[2]*y[3]*z[6]+x[0]*y[3]*z[4]+z[0]*x[3]*y[4]+s7;
+  s8 = x[5]*y[4]*z[7]+s6+y[5]*x[6]*z[4]-y[5]*x[4]*z[6]+z[6]*x[5]*y[7]-x[6]*
+y[2]*z[7]-x[6]*y[7]*z[5]+x[5]*y[6]*z[2]+x[6]*y[5]*z[7]+x[6]*y[7]*z[2]+y[6]*x[7]
+*z[4]-y[6]*x[4]*z[7]-y[6]*x[7]*z[3]+z[6]*x[7]*y[2]+x[2]*y[5]*z[6]-x[2]*y[6]*z
+[5]+y[6]*x[2]*z[7]+x[6]*y[2]*z[5];
+  s7 = s8-x[5]*y[2]*z[6]-z[6]*x[7]*y[5]-z[5]*x[7]*y[4]+z[5]*x[0]*y[4]-y[5]*
+x[4]*z[7]+y[0]*x[4]*z[7]-z[6]*x[2]*y[7]-x[5]*y[4]*z[0]-x[5]*y[7]*z[4]-y[0]*x[7]
+*z[4]+y[5]*x[4]*z[1]-x[6]*y[7]*z[4]+x[7]*y[4]*z[3]-x[4]*y[7]*z[3]+x[3]*y[7]*z
+[4]-x[7]*y[3]*z[4]-x[6]*y[3]*z[7]+x[6]*y[4]*z[7];
+  s8 = -x[3]*y[4]*z[7]+x[4]*y[3]*z[7]-z[6]*x[7]*y[4]-z[1]*x[6]*y[5]+x[6]*y
+[7]*z[3]-x[1]*y[6]*z[5]-y[1]*x[5]*z[6]+z[5]*x[4]*y[7]-z[5]*x[4]*y[0]+x[1]*y[5]*
+z[6]-y[6]*x[5]*z[7]-y[2]*x[3]*z[1]+z[1]*x[5]*y[6]-y[5]*x[1]*z[4]+z[6]*x[4]*y[7]
++x[5]*y[1]*z[4]-x[5]*y[6]*z[4]+y[6]*x[3]*z[7]-x[5]*y[4]*z[1];
+  s5 = s8+x[5]*y[4]*z[6]+z[5]*x[1]*y[4]+y[1]*x[6]*z[5]-z[6]*x[3]*y[7]+z[6]*
+x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
+*z[3]+z[2]*x[6]*y[3]+z[1]*x[6]*y[2]+z[2]*x[3]*y[1]-z[2]*x[1]*y[3]-z[2]*x[3]*y
+[6]+y[2]*x[1]*z[3]+y[1]*x[2]*z[6]-z[0]*x[7]*y[3]+s7;
+  s4 = 1/s5;
+  s2 = s3*s4;
+  const double unknown1 = s1*s2;
+  s1 = 1.0/6.0;
+  s8 = -z[2]*x[1]*y[2]*z[5]+z[2]*y[1]*x[2]*z[5]-z[2]*z[1]*x[2]*y[5]+z[2]*z
+[1]*x[5]*y[2]+2.0*y[5]*x[7]*z[4]*z[4]-y[1]*x[2]*z[0]*z[0]+x[0]*y[3]*z[7]*z[7]
+-2.0*z[5]*z[5]*x[4]*y[1]+2.0*z[5]*z[5]*x[1]*y[4]+z[5]*z[5]*x[0]*y[4]-2.0*z[2]*z
+[2]*x[1]*y[3]+2.0*z[2]*z[2]*x[3]*y[1]-x[0]*y[4]*z[7]*z[7]-y[0]*x[3]*z[7]*z[7]+x
+[1]*y[0]*z[5]*z[5];
+  s7 = s8-y[1]*x[0]*z[5]*z[5]+z[1]*y[1]*x[2]*z[6]+y[1]*x[0]*z[2]*z[2]+z[2]*
+z[2]*x[3]*y[0]-z[2]*z[2]*x[0]*y[3]-x[1]*y[0]*z[2]*z[2]+2.0*z[5]*z[5]*x[4]*y[6]
+-2.0*z[5]*z[5]*x[6]*y[4]-z[5]*z[5]*x[7]*y[4]-x[6]*y[7]*z[5]*z[5]+2.0*z[2]*y[1]*
+x[2]*z[6]-2.0*z[2]*x[1]*y[2]*z[6]+2.0*z[2]*z[1]*x[6]*y[2]-y[6]*x[5]*z[7]*z[7]+
+2.0*x[6]*y[4]*z[7]*z[7];
+  s8 = -2.0*y[6]*x[4]*z[7]*z[7]+x[6]*y[5]*z[7]*z[7]-2.0*z[2]*z[1]*x[2]*y[6]
++z[4]*y[6]*x[7]*z[5]+x[5]*y[4]*z[6]*z[6]+z[6]*z[6]*x[4]*y[7]-z[6]*z[6]*x[7]*y
+[4]-2.0*z[6]*z[6]*x[7]*y[5]+2.0*z[6]*z[6]*x[5]*y[7]-y[5]*x[4]*z[6]*z[6]+2.0*z
+[0]*z[0]*x[3]*y[4]-x[6]*y[5]*z[2]*z[2]+z[1]*z[1]*x[5]*y[6]-z[1]*z[1]*x[6]*y[5]-
+z[5]*z[5]*x[4]*y[0];
+  s6 = s8+2.0*x[1]*y[3]*z[0]*z[0]+2.0*x[1]*y[6]*z[2]*z[2]-2.0*y[1]*x[6]*z
+[2]*z[2]-y[1]*x[5]*z[2]*z[2]-z[1]*z[1]*x[2]*y[6]-2.0*z[1]*z[1]*x[2]*y[5]+2.0*z
+[1]*z[1]*x[5]*y[2]+z[1]*y[1]*x[6]*z[5]+y[1]*x[2]*z[5]*z[5]+z[2]*z[1]*x[2]*y[0]+
+z[1]*x[1]*y[5]*z[6]-z[1]*x[1]*y[6]*z[5]-z[1]*y[1]*x[5]*z[6]-z[1]*x[2]*y[6]*z[5]
++z[1]*x[6]*y[2]*z[5]+s7;
+  s8 = -x[1]*y[2]*z[5]*z[5]+z[1]*x[5]*y[6]*z[2]-2.0*z[2]*z[2]*x[3]*y[6]+2.0
+*z[2]*z[2]*x[6]*y[3]+z[2]*z[2]*x[7]*y[3]-z[2]*z[2]*x[3]*y[7]-z[1]*x[6]*y[5]*z
+[2]+2.0*z[1]*x[1]*y[5]*z[2]-2.0*x[3]*y[4]*z[7]*z[7]+2.0*x[4]*y[3]*z[7]*z[7]+x
+[5]*y[6]*z[2]*z[2]+y[1]*x[2]*z[6]*z[6]+y[0]*x[4]*z[7]*z[7]+z[2]*x[2]*y[3]*z[0]-
+x[1]*y[2]*z[6]*z[6];
+  s7 = s8-z[7]*z[2]*x[3]*y[7]+x[2]*y[6]*z[3]*z[3]-y[2]*x[6]*z[3]*z[3]-z[6]*
+x[2]*y[3]*z[7]-z[2]*z[1]*x[0]*y[2]+z[6]*z[2]*x[6]*y[3]-z[6]*z[2]*x[3]*y[6]+z[6]
+*x[2]*y[6]*z[3]+z[2]*x[1]*y[2]*z[0]+z[6]*y[2]*x[3]*z[7]-z[4]*z[5]*x[6]*y[4]+z
+[4]*z[5]*x[4]*y[6]-z[4]*y[6]*x[5]*z[7]+z[4]*z[6]*x[4]*y[7]+z[4]*x[5]*y[4]*z[6];
+  s8 = -z[6]*y[2]*x[6]*z[3]-z[4]*y[5]*x[4]*z[6]-z[2]*y[1]*x[5]*z[6]+z[2]*x
+[1]*y[5]*z[6]+z[4]*x[6]*y[4]*z[7]+2.0*z[4]*z[5]*x[4]*y[7]-z[4]*z[6]*x[7]*y[4]+x
+[6]*y[7]*z[3]*z[3]-2.0*z[4]*z[5]*x[7]*y[4]-2.0*z[4]*y[5]*x[4]*z[7]-z[4]*y[6]*x
+[4]*z[7]+z[4]*x[6]*y[5]*z[7]-z[4]*x[6]*y[7]*z[5]+2.0*z[4]*x[5]*y[4]*z[7]+z[2]*x
+[2]*y[5]*z[6]-z[2]*x[2]*y[6]*z[5];
+  s5 = s8+z[2]*x[6]*y[2]*z[5]-z[2]*x[5]*y[2]*z[6]-z[2]*x[2]*y[3]*z[7]-x[2]*
+y[3]*z[7]*z[7]+2.0*z[2]*x[2]*y[3]*z[1]-z[2]*y[2]*x[3]*z[0]+z[2]*y[2]*x[0]*z[3]-
+z[2]*x[2]*y[0]*z[3]-z[7]*y[2]*x[7]*z[3]+z[7]*z[2]*x[7]*y[3]+z[7]*x[2]*y[7]*z[3]
++z[6]*y[1]*x[2]*z[5]-z[6]*x[1]*y[2]*z[5]+z[5]*x[1]*y[5]*z[2]+s6+s7;
+  s8 = z[5]*z[1]*x[5]*y[2]-z[5]*z[1]*x[2]*y[5]-y[6]*x[7]*z[2]*z[2]+2.0*z[2]
+*x[2]*y[6]*z[3]-2.0*z[2]*x[2]*y[3]*z[6]+2.0*z[2]*y[2]*x[3]*z[6]+y[2]*x[3]*z[6]*
+z[6]+y[6]*x[7]*z[5]*z[5]+z[2]*y[2]*x[3]*z[7]-z[2]*y[2]*x[7]*z[3]-2.0*z[2]*y[2]*
+x[6]*z[3]+z[2]*x[2]*y[7]*z[3]+x[6]*y[2]*z[5]*z[5]-2.0*z[2]*x[2]*y[1]*z[3]-x[2]*
+y[6]*z[5]*z[5];
+  s7 = s8-y[1]*x[5]*z[6]*z[6]+z[6]*x[1]*y[6]*z[2]-z[3]*z[2]*x[3]*y[6]+z[6]*
+z[1]*x[6]*y[2]-z[6]*z[1]*x[2]*y[6]-z[6]*y[1]*x[6]*z[2]-2.0*x[5]*y[2]*z[6]*z[6]+
+z[4]*z[1]*x[0]*y[4]-z[3]*x[2]*y[3]*z[6]-z[5]*y[1]*x[5]*z[2]+z[3]*y[2]*x[3]*z[6]
++2.0*x[2]*y[5]*z[6]*z[6]-z[5]*x[1]*y[5]*z[0]+y[2]*x[3]*z[7]*z[7]-x[2]*y[3]*z[6]
+*z[6];
+  s8 = z[5]*y[5]*x[4]*z[0]+z[3]*z[2]*x[6]*y[3]+x[1]*y[5]*z[6]*z[6]+z[5]*y
+[5]*x[7]*z[4]-z[1]*x[1]*y[2]*z[6]+z[1]*x[1]*y[6]*z[2]+2.0*z[6]*y[6]*x[7]*z[5]-z
+[7]*y[6]*x[7]*z[2]-z[3]*y[6]*x[7]*z[2]+x[6]*y[7]*z[2]*z[2]-2.0*z[6]*y[6]*x[7]*z
+[2]-2.0*x[6]*y[3]*z[7]*z[7]-x[6]*y[2]*z[7]*z[7]-z[5]*x[6]*y[5]*z[2]+y[6]*x[2]*z
+[7]*z[7];
+  s6 = s8+2.0*y[6]*x[3]*z[7]*z[7]+z[6]*z[6]*x[7]*y[3]-y[6]*x[7]*z[3]*z[3]+z
+[5]*x[5]*y[0]*z[4]+2.0*z[6]*z[6]*x[7]*y[2]-2.0*z[6]*z[6]*x[2]*y[7]-z[6]*z[6]*x
+[3]*y[7]+z[7]*y[6]*x[7]*z[5]+z[7]*y[5]*x[7]*z[4]-2.0*z[7]*x[7]*y[3]*z[4]+2.0*z
+[7]*x[3]*y[7]*z[4]-2.0*z[7]*x[4]*y[7]*z[3]+2.0*z[7]*x[7]*y[4]*z[3]-z[7]*y[0]*x
+[7]*z[4]-2.0*z[7]*z[6]*x[3]*y[7]+s7;
+  s8 = s6+2.0*z[7]*z[6]*x[7]*y[3]+2.0*z[7]*x[6]*y[7]*z[3]+z[7]*x[6]*y[7]*z
+[2]-2.0*z[7]*y[6]*x[7]*z[3]+z[7]*z[6]*x[7]*y[2]-z[7]*z[6]*x[2]*y[7]+z[5]*y[1]*x
+[5]*z[0]-z[5]*z[1]*x[5]*y[0]+2.0*y[1]*x[6]*z[5]*z[5]-2.0*x[1]*y[6]*z[5]*z[5]+z
+[5]*z[1]*x[0]*y[5]+z[6]*y[6]*x[3]*z[7]+2.0*z[6]*x[6]*y[7]*z[2]-z[6]*y[6]*x[7]*z
+[3];
+  s7 = s8+2.0*z[6]*y[6]*x[2]*z[7]-z[6]*x[6]*y[3]*z[7]+z[6]*x[6]*y[7]*z[3]
+-2.0*z[6]*x[6]*y[2]*z[7]-2.0*z[1]*y[1]*x[5]*z[2]-z[1]*y[1]*x[6]*z[2]-z[7]*z[0]*
+x[7]*y[3]-2.0*z[6]*x[6]*y[5]*z[2]-z[2]*z[6]*x[3]*y[7]+z[2]*x[6]*y[7]*z[3]-z[2]*
+z[6]*x[2]*y[7]+y[5]*x[6]*z[4]*z[4]+z[2]*y[6]*x[2]*z[7]+y[6]*x[7]*z[4]*z[4]+z[2]
+*z[6]*x[7]*y[2]-2.0*x[5]*y[7]*z[4]*z[4];
+  s8 = -x[6]*y[7]*z[4]*z[4]-z[5]*y[5]*x[0]*z[4]-z[2]*x[6]*y[2]*z[7]-x[5]*y
+[6]*z[4]*z[4]-2.0*z[5]*y[1]*x[5]*z[6]+2.0*z[5]*z[1]*x[5]*y[6]+2.0*z[5]*x[1]*y
+[5]*z[6]-2.0*z[5]*z[1]*x[6]*y[5]-z[5]*x[5]*y[2]*z[6]+z[5]*x[5]*y[6]*z[2]+z[5]*x
+[2]*y[5]*z[6]+z[5]*z[5]*x[4]*y[7]-y[5]*x[4]*z[7]*z[7]+x[5]*y[4]*z[7]*z[7]+z[6]*
+z[1]*x[5]*y[6]+z[6]*y[1]*x[6]*z[5];
+  s4 = s8-z[6]*z[1]*x[6]*y[5]-z[6]*x[1]*y[6]*z[5]+z[2]*z[6]*x[7]*y[3]+2.0*z
+[6]*x[6]*y[2]*z[5]+2.0*z[6]*x[5]*y[6]*z[2]-2.0*z[6]*x[2]*y[6]*z[5]+z[7]*z[0]*x
+[3]*y[7]+z[7]*z[0]*x[7]*y[4]+z[3]*z[6]*x[7]*y[3]-z[3]*z[6]*x[3]*y[7]-z[3]*x[6]*
+y[3]*z[7]+z[3]*y[6]*x[2]*z[7]-z[3]*x[6]*y[2]*z[7]+z[5]*x[5]*y[4]*z[7]+s5+s7;
+  s8 = s4+z[3]*y[6]*x[3]*z[7]-z[7]*x[0]*y[7]*z[3]+z[6]*x[5]*y[4]*z[7]+z[7]*
+y[0]*x[7]*z[3]+z[5]*z[6]*x[4]*y[7]-2.0*z[5]*x[5]*y[6]*z[4]+2.0*z[5]*x[5]*y[4]*z
+[6]-z[5]*x[5]*y[7]*z[4]-z[5]*y[6]*x[5]*z[7]-z[5]*z[6]*x[7]*y[4]-z[7]*z[0]*x[4]*
+y[7]-z[5]*z[6]*x[7]*y[5]-z[5]*y[5]*x[4]*z[7]+z[7]*x[0]*y[7]*z[4];
+  s7 = s8-2.0*z[5]*y[5]*x[4]*z[6]+z[5]*z[6]*x[5]*y[7]+z[5]*x[6]*y[5]*z[7]+
+2.0*z[5]*y[5]*x[6]*z[4]+z[6]*z[5]*x[4]*y[6]-z[6]*x[5]*y[6]*z[4]-z[6]*z[5]*x[6]*
+y[4]-z[6]*x[6]*y[7]*z[4]-2.0*z[6]*y[6]*x[5]*z[7]+z[6]*x[6]*y[4]*z[7]-z[6]*y[5]*
+x[4]*z[7]-z[6]*y[6]*x[4]*z[7]+z[6]*y[6]*x[7]*z[4]+z[6]*y[5]*x[6]*z[4]+2.0*z[6]*
+x[6]*y[5]*z[7];
+  s8 = -2.0*z[6]*x[6]*y[7]*z[5]-z[2]*y[1]*x[2]*z[0]+2.0*z[7]*z[6]*x[4]*y[7]
+-2.0*z[7]*x[6]*y[7]*z[4]-2.0*z[7]*z[6]*x[7]*y[4]+z[7]*z[5]*x[4]*y[7]-z[7]*z[5]*
+x[7]*y[4]-z[7]*x[5]*y[7]*z[4]+2.0*z[7]*y[6]*x[7]*z[4]-z[7]*z[6]*x[7]*y[5]+z[7]*
+z[6]*x[5]*y[7]-z[7]*x[6]*y[7]*z[5]+z[1]*z[1]*x[6]*y[2]+s7+x[1]*y[5]*z[2]*z[2];
+  s6 = s8+2.0*z[2]*y[2]*x[1]*z[3]-2.0*z[2]*y[2]*x[3]*z[1]-2.0*x[1]*y[4]*z
+[0]*z[0]+2.0*y[1]*x[4]*z[0]*z[0]+2.0*x[2]*y[7]*z[3]*z[3]-2.0*y[2]*x[7]*z[3]*z
+[3]-x[1]*y[5]*z[0]*z[0]+z[0]*z[0]*x[7]*y[4]+z[0]*z[0]*x[3]*y[7]+x[2]*y[3]*z[0]*
+z[0]-2.0*y[1]*x[3]*z[0]*z[0]+y[5]*x[4]*z[0]*z[0]-2.0*z[0]*z[0]*x[4]*y[3]+x[1]*y
+[2]*z[0]*z[0]-z[0]*z[0]*x[4]*y[7]+y[1]*x[5]*z[0]*z[0];
+  s8 = s6-y[2]*x[3]*z[0]*z[0]+y[1]*x[0]*z[3]*z[3]-2.0*x[0]*y[7]*z[3]*z[3]-x
+[0]*y[4]*z[3]*z[3]-2.0*x[2]*y[0]*z[3]*z[3]-x[1]*y[0]*z[3]*z[3]+y[0]*x[4]*z[3]*z
+[3]-2.0*z[0]*y[1]*x[0]*z[4]+2.0*z[0]*z[1]*x[0]*y[4]+2.0*z[0]*x[1]*y[0]*z[4]-2.0
+*z[0]*z[1]*x[4]*y[0]-2.0*z[3]*x[2]*y[3]*z[7]-2.0*z[3]*z[2]*x[3]*y[7]+2.0*z[3]*z
+[2]*x[7]*y[3];
+  s7 = s8+2.0*z[3]*y[2]*x[3]*z[7]+2.0*z[5]*y[5]*x[4]*z[1]+2.0*z[0]*y[1]*x
+[0]*z[3]-z[0]*y[0]*x[3]*z[7]-2.0*z[0]*y[0]*x[3]*z[4]-z[0]*x[1]*y[0]*z[2]+z[0]*z
+[1]*x[2]*y[0]-z[0]*y[1]*x[0]*z[5]-z[0]*z[1]*x[0]*y[2]-z[0]*x[0]*y[7]*z[3]-2.0*z
+[0]*z[1]*x[0]*y[3]-z[5]*x[5]*y[4]*z[0]-2.0*z[0]*x[0]*y[4]*z[3]+z[0]*x[0]*y[7]*z
+[4]-z[0]*z[2]*x[0]*y[3];
+  s8 = s7+z[0]*x[5]*y[0]*z[4]+z[0]*z[1]*x[0]*y[5]-z[0]*x[2]*y[0]*z[3]-z[0]*
+z[1]*x[5]*y[0]-2.0*z[0]*x[1]*y[0]*z[3]+2.0*z[0]*y[0]*x[4]*z[3]-z[0]*x[0]*y[4]*z
+[7]+z[0]*x[1]*y[0]*z[5]+z[0]*y[0]*x[7]*z[3]+z[0]*y[2]*x[0]*z[3]-z[0]*y[5]*x[0]*
+z[4]+z[0]*z[2]*x[3]*y[0]+z[0]*x[2]*y[3]*z[1]+z[0]*x[0]*y[3]*z[7]-z[0]*x[2]*y[1]
+*z[3];
+  s5 = s8+z[0]*y[1]*x[0]*z[2]+z[3]*x[1]*y[3]*z[0]-2.0*z[3]*y[0]*x[3]*z[7]-z
+[3]*y[0]*x[3]*z[4]-z[3]*x[1]*y[0]*z[2]+z[3]*z[0]*x[7]*y[4]+2.0*z[3]*z[0]*x[3]*y
+[7]+2.0*z[3]*x[2]*y[3]*z[0]-z[3]*y[1]*x[3]*z[0]-z[3]*z[1]*x[0]*y[3]-z[3]*z[0]*x
+[4]*y[3]+z[3]*x[1]*y[2]*z[0]-z[3]*z[0]*x[4]*y[7]-2.0*z[3]*z[2]*x[0]*y[3]-z[3]*x
+[0]*y[4]*z[7]-2.0*z[3]*y[2]*x[3]*z[0];
+  s8 = s5+2.0*z[3]*z[2]*x[3]*y[0]+z[3]*x[2]*y[3]*z[1]+2.0*z[3]*x[0]*y[3]*z
+[7]+z[3]*y[1]*x[0]*z[2]-z[4]*y[0]*x[3]*z[7]-z[4]*x[1]*y[5]*z[0]-z[4]*y[1]*x[0]*
+z[5]+2.0*z[4]*z[0]*x[7]*y[4]+z[4]*z[0]*x[3]*y[7]+2.0*z[4]*y[5]*x[4]*z[0]+2.0*y
+[0]*x[7]*z[3]*z[3]+2.0*y[2]*x[0]*z[3]*z[3]-x[2]*y[1]*z[3]*z[3]-y[0]*x[3]*z[4]*z
+[4];
+  s7 = s8-y[1]*x[0]*z[4]*z[4]+x[1]*y[0]*z[4]*z[4]+2.0*x[0]*y[7]*z[4]*z[4]+
+2.0*x[5]*y[0]*z[4]*z[4]-2.0*y[5]*x[0]*z[4]*z[4]+2.0*z[1]*z[1]*x[2]*y[0]-2.0*z
+[1]*z[1]*x[0]*y[2]+z[1]*z[1]*x[0]*y[4]-z[1]*z[1]*x[0]*y[3]-z[1]*z[1]*x[4]*y[0]+
+2.0*z[1]*z[1]*x[0]*y[5]-2.0*z[1]*z[1]*x[5]*y[0]+x[2]*y[3]*z[1]*z[1]-x[5]*y[4]*z
+[0]*z[0]-z[0]*z[0]*x[7]*y[3];
+  s8 = s7+x[7]*y[4]*z[3]*z[3]-x[4]*y[7]*z[3]*z[3]+y[2]*x[1]*z[3]*z[3]+x[0]*
+y[3]*z[4]*z[4]-2.0*y[0]*x[7]*z[4]*z[4]+x[3]*y[7]*z[4]*z[4]-x[7]*y[3]*z[4]*z[4]-
+y[5]*x[1]*z[4]*z[4]+x[5]*y[1]*z[4]*z[4]+z[1]*z[1]*x[3]*y[0]+y[5]*x[4]*z[1]*z[1]
+-y[2]*x[3]*z[1]*z[1]-x[5]*y[4]*z[1]*z[1]-z[4]*x[0]*y[4]*z[3]-z[4]*z[0]*x[4]*y
+[3];
+  s6 = s8-z[4]*z[1]*x[4]*y[0]-2.0*z[4]*z[0]*x[4]*y[7]+z[4]*y[1]*x[5]*z[0]
+-2.0*z[5]*x[5]*y[4]*z[1]-z[4]*x[1]*y[4]*z[0]+z[4]*y[0]*x[4]*z[3]-2.0*z[4]*x[0]*
+y[4]*z[7]+z[4]*x[1]*y[0]*z[5]-2.0*z[1]*x[1]*y[2]*z[5]+z[4]*x[0]*y[3]*z[7]+2.0*z
+[5]*x[5]*y[1]*z[4]+z[4]*y[1]*x[4]*z[0]+z[1]*y[1]*x[0]*z[3]+z[1]*x[1]*y[3]*z[0]
+-2.0*z[1]*x[1]*y[5]*z[0]-2.0*z[1]*x[1]*y[0]*z[2];
+  s8 = s6-2.0*z[1]*y[1]*x[0]*z[5]-z[1]*y[1]*x[0]*z[4]+2.0*z[1]*y[1]*x[2]*z
+[5]-z[1]*y[1]*x[3]*z[0]-2.0*z[5]*y[5]*x[1]*z[4]+z[1]*y[5]*x[4]*z[0]+z[1]*x[1]*y
+[0]*z[4]+2.0*z[1]*x[1]*y[2]*z[0]-z[1]*z[2]*x[0]*y[3]+2.0*z[1]*y[1]*x[5]*z[0]-z
+[1]*x[1]*y[0]*z[3]-z[1]*x[1]*y[4]*z[0]+2.0*z[1]*x[1]*y[0]*z[5]-z[1]*y[2]*x[3]*z
+[0];
+  s7 = s8+z[1]*z[2]*x[3]*y[0]-z[1]*x[2]*y[1]*z[3]+z[1]*y[1]*x[4]*z[0]+2.0*z
+[1]*y[1]*x[0]*z[2]+2.0*z[0]*z[1]*x[3]*y[0]+2.0*z[0]*x[0]*y[3]*z[4]+z[0]*z[5]*x
+[0]*y[4]+z[0]*y[0]*x[4]*z[7]-z[0]*y[0]*x[7]*z[4]-z[0]*x[7]*y[3]*z[4]-z[0]*z[5]*
+x[4]*y[0]-z[0]*x[5]*y[4]*z[1]+z[3]*z[1]*x[3]*y[0]+z[3]*x[0]*y[3]*z[4]+z[3]*z[0]
+*x[3]*y[4]+z[3]*y[0]*x[4]*z[7];
+  s8 = s7+z[3]*x[3]*y[7]*z[4]-z[3]*x[7]*y[3]*z[4]-z[3]*x[3]*y[4]*z[7]+z[3]*
+x[4]*y[3]*z[7]-z[3]*y[2]*x[3]*z[1]+z[3]*z[2]*x[3]*y[1]-z[3]*z[2]*x[1]*y[3]-2.0*
+z[3]*z[0]*x[7]*y[3]+z[4]*z[0]*x[3]*y[4]+2.0*z[4]*z[5]*x[0]*y[4]+2.0*z[4]*y[0]*x
+[4]*z[7]-2.0*z[4]*x[5]*y[4]*z[0]+z[4]*y[5]*x[4]*z[1]+z[4]*x[7]*y[4]*z[3]-z[4]*x
+[4]*y[7]*z[3];
+  s3 = s8-z[4]*x[3]*y[4]*z[7]+z[4]*x[4]*y[3]*z[7]-2.0*z[4]*z[5]*x[4]*y[0]-z
+[4]*x[5]*y[4]*z[1]+z[4]*z[5]*x[1]*y[4]-z[4]*z[5]*x[4]*y[1]-2.0*z[1]*y[1]*x[2]*z
+[0]+z[1]*z[5]*x[0]*y[4]-z[1]*z[5]*x[4]*y[0]-z[1]*y[5]*x[1]*z[4]+z[1]*x[5]*y[1]*
+z[4]+z[1]*z[5]*x[1]*y[4]-z[1]*z[5]*x[4]*y[1]+z[1]*z[2]*x[3]*y[1]-z[1]*z[2]*x[1]
+*y[3]+z[1]*y[2]*x[1]*z[3];
+  s8 = y[1]*x[0]*z[3]+x[1]*y[3]*z[0]-y[0]*x[3]*z[7]-x[1]*y[5]*z[0]-y[0]*x
+[3]*z[4]-x[1]*y[0]*z[2]+z[1]*x[2]*y[0]-y[1]*x[0]*z[5]-z[1]*x[0]*y[2]-y[1]*x[0]*
+z[4]+z[1]*x[5]*y[2]+z[0]*x[7]*y[4]+z[0]*x[3]*y[7]+z[1]*x[0]*y[4]-x[1]*y[2]*z[5]
++x[2]*y[3]*z[0]+y[1]*x[2]*z[5]-x[2]*y[3]*z[7];
+  s7 = s8-z[1]*x[2]*y[5]-y[1]*x[3]*z[0]-x[0]*y[7]*z[3]-z[1]*x[0]*y[3]+y[5]*
+x[4]*z[0]-x[0]*y[4]*z[3]+y[5]*x[7]*z[4]-z[0]*x[4]*y[3]+x[1]*y[0]*z[4]-z[2]*x[3]
+*y[7]-y[6]*x[7]*z[2]+x[1]*y[5]*z[2]+y[6]*x[7]*z[5]+x[0]*y[7]*z[4]+x[1]*y[2]*z
+[0]-z[1]*x[4]*y[0]-z[0]*x[4]*y[7]-z[2]*x[0]*y[3];
+  s8 = x[5]*y[0]*z[4]+z[1]*x[0]*y[5]-x[2]*y[0]*z[3]-z[1]*x[5]*y[0]+y[1]*x
+[5]*z[0]-x[1]*y[0]*z[3]-x[1]*y[4]*z[0]-y[1]*x[5]*z[2]+x[2]*y[7]*z[3]+y[0]*x[4]*
+z[3]-x[0]*y[4]*z[7]+x[1]*y[0]*z[5]-y[1]*x[6]*z[2]-y[2]*x[6]*z[3]+y[0]*x[7]*z[3]
+-y[2]*x[7]*z[3]+z[2]*x[7]*y[3]+y[2]*x[0]*z[3];
+  s6 = s8+y[2]*x[3]*z[7]-y[2]*x[3]*z[0]-x[6]*y[5]*z[2]-y[5]*x[0]*z[4]+z[2]*
+x[3]*y[0]+x[2]*y[3]*z[1]+x[0]*y[3]*z[7]-x[2]*y[1]*z[3]+y[1]*x[4]*z[0]+y[1]*x[0]
+*z[2]-z[1]*x[2]*y[6]+y[2]*x[3]*z[6]-y[1]*x[2]*z[0]+z[1]*x[3]*y[0]-x[1]*y[2]*z
+[6]-x[2]*y[3]*z[6]+x[0]*y[3]*z[4]+z[0]*x[3]*y[4]+s7;
+  s8 = x[5]*y[4]*z[7]+s6+y[5]*x[6]*z[4]-y[5]*x[4]*z[6]+z[6]*x[5]*y[7]-x[6]*
+y[2]*z[7]-x[6]*y[7]*z[5]+x[5]*y[6]*z[2]+x[6]*y[5]*z[7]+x[6]*y[7]*z[2]+y[6]*x[7]
+*z[4]-y[6]*x[4]*z[7]-y[6]*x[7]*z[3]+z[6]*x[7]*y[2]+x[2]*y[5]*z[6]-x[2]*y[6]*z
+[5]+y[6]*x[2]*z[7]+x[6]*y[2]*z[5];
+  s7 = s8-x[5]*y[2]*z[6]-z[6]*x[7]*y[5]-z[5]*x[7]*y[4]+z[5]*x[0]*y[4]-y[5]*
+x[4]*z[7]+y[0]*x[4]*z[7]-z[6]*x[2]*y[7]-x[5]*y[4]*z[0]-x[5]*y[7]*z[4]-y[0]*x[7]
+*z[4]+y[5]*x[4]*z[1]-x[6]*y[7]*z[4]+x[7]*y[4]*z[3]-x[4]*y[7]*z[3]+x[3]*y[7]*z
+[4]-x[7]*y[3]*z[4]-x[6]*y[3]*z[7]+x[6]*y[4]*z[7];
+  s8 = -x[3]*y[4]*z[7]+x[4]*y[3]*z[7]-z[6]*x[7]*y[4]-z[1]*x[6]*y[5]+x[6]*y
+[7]*z[3]-x[1]*y[6]*z[5]-y[1]*x[5]*z[6]+z[5]*x[4]*y[7]-z[5]*x[4]*y[0]+x[1]*y[5]*
+z[6]-y[6]*x[5]*z[7]-y[2]*x[3]*z[1]+z[1]*x[5]*y[6]-y[5]*x[1]*z[4]+z[6]*x[4]*y[7]
++x[5]*y[1]*z[4]-x[5]*y[6]*z[4]+y[6]*x[3]*z[7]-x[5]*y[4]*z[1];
+  s5 = s8+x[5]*y[4]*z[6]+z[5]*x[1]*y[4]+y[1]*x[6]*z[5]-z[6]*x[3]*y[7]+z[6]*
+x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
+*z[3]+z[2]*x[6]*y[3]+z[1]*x[6]*y[2]+z[2]*x[3]*y[1]-z[2]*x[1]*y[3]-z[2]*x[3]*y
+[6]+y[2]*x[1]*z[3]+y[1]*x[2]*z[6]-z[0]*x[7]*y[3]+s7;
+  s4 = 1/s5;
+  s2 = s3*s4;
+  const double unknown2 = s1*s2;
+
+  return Point<3> (unknown0, unknown1, unknown2);
+};
+
+
+
+
+template <>
+double HexAccessor<3>::measure () const {
+/*
+  Get the computation of the measure by the same little Maple script as above.
+*/
+
+  const double x[8] = { vertex(0)(0),
+                       vertex(1)(0),
+                       vertex(2)(0),
+                       vertex(3)(0),
+                       vertex(4)(0),
+                       vertex(5)(0),
+                       vertex(6)(0),
+                       vertex(7)(0)   };
+  const double y[8] = { vertex(0)(1),
+                       vertex(1)(1),
+                       vertex(2)(1),
+                       vertex(3)(1),
+                       vertex(4)(1),
+                       vertex(5)(1),
+                       vertex(6)(1),
+                       vertex(7)(1)  };
+  const double z[8] = { vertex(0)(2),
+                       vertex(1)(2),
+                       vertex(2)(2),
+                       vertex(3)(2),
+                       vertex(4)(2),
+                       vertex(5)(2),
+                       vertex(6)(2),
+                       vertex(7)(2)  };
+
+  double s1, s2, s3;
+  
+  s3 = -x[2]*y[7]*z[3]/12.0+x[1]*y[4]*z[0]/12.0-x[0]*y[3]*z[7]/12.0-z[1]*x
+[2]*y[0]/12.0+x[5]*y[4]*z[0]/12.0+x[1]*y[5]*z[0]/12.0-x[1]*y[2]*z[0]/12.0-y[2]*
+x[3]*z[7]/12.0-x[1]*y[0]*z[4]/12.0-y[1]*x[0]*z[2]/12.0-y[0]*x[7]*z[3]/12.0+y[5]
+*x[4]*z[7]/12.0-x[0]*y[3]*z[4]/12.0-y[1]*x[0]*z[3]/12.0-z[0]*x[7]*y[4]/12.0+x
+[1]*y[0]*z[3]/12.0-x[2]*y[3]*z[0]/12.0-y[1]*x[2]*z[5]/12.0;
+  s2 = s3+y[0]*x[3]*z[4]/12.0+y[1]*x[2]*z[0]/12.0+y[2]*x[7]*z[3]/12.0+z[1]*
+x[4]*y[0]/12.0-y[5]*x[4]*z[0]/12.0-y[1]*x[5]*z[0]/12.0+x[5]*y[7]*z[4]/12.0+y[1]
+*x[3]*z[0]/12.0+x[0]*y[4]*z[7]/12.0+z[0]*x[7]*y[3]/12.0-z[2]*x[3]*y[0]/12.0+y
+[1]*x[0]*z[5]/12.0-x[1]*y[5]*z[2]/12.0+y[1]*x[0]*z[4]/12.0+z[1]*x[2]*y[5]/12.0-
+x[5]*y[0]*z[4]/12.0+y[2]*x[3]*z[1]/12.0+x[1]*y[0]*z[2]/12.0;
+  s3 = -z[1]*x[0]*y[4]/12.0+z[1]*x[0]*y[2]/12.0-x[0]*y[7]*z[4]/12.0+z[0]*x
+[4]*y[7]/12.0+x[2]*y[3]*z[7]/12.0+y[2]*x[6]*z[3]/12.0+y[1]*x[6]*z[2]/12.0-y[2]*
+x[1]*z[3]/12.0+x[1]*y[2]*z[5]/12.0+y[0]*x[3]*z[7]/12.0+y[2]*x[3]*z[0]/12.0-y[0]
+*x[4]*z[3]/12.0-y[2]*x[0]*z[3]/12.0-y[1]*x[4]*z[0]/12.0+z[1]*x[5]*y[0]/12.0+x
+[1]*y[2]*z[6]/12.0-x[1]*y[0]*z[5]/12.0-x[2]*y[3]*z[1]/12.0;
+  s1 = s3-z[0]*x[3]*y[4]/12.0+z[1]*x[0]*y[3]/12.0-z[1]*x[5]*y[2]/12.0+z[1]*
+x[2]*y[6]/12.0-z[2]*x[3]*y[1]/12.0+z[2]*x[3]*y[6]/12.0+x[2]*y[1]*z[3]/12.0-z[1]
+*x[3]*y[0]/12.0+x[2]*y[3]*z[6]/12.0-z[0]*x[3]*y[7]/12.0+y[5]*x[0]*z[4]/12.0-z
+[1]*x[6]*y[2]/12.0-z[2]*x[6]*y[3]/12.0+z[2]*x[0]*y[3]/12.0+z[2]*x[3]*y[7]/12.0+
+z[2]*x[1]*y[3]/12.0+y[1]*x[5]*z[2]/12.0-z[2]*x[7]*y[3]/12.0+s2;
+  s3 = x[0]*y[7]*z[3]/12.0-z[1]*x[0]*y[5]/12.0-x[1]*y[3]*z[0]/12.0-x[1]*y
+[6]*z[2]/12.0-x[2]*y[6]*z[3]/12.0-x[5]*y[4]*z[7]/12.0+z[0]*x[4]*y[3]/12.0+x[0]*
+y[4]*z[3]/12.0-x[6]*y[5]*z[7]/12.0-x[6]*y[7]*z[2]/12.0+z[1]*x[6]*y[5]/12.0+y[6]
+*x[4]*z[7]/12.0+y[1]*x[5]*z[6]/12.0+x[1]*y[6]*z[5]/12.0-y[5]*x[7]*z[4]/12.0+y
+[0]*x[7]*z[4]/12.0-y[0]*x[4]*z[7]/12.0-z[5]*x[0]*y[4]/12.0;
+  s2 = s3+z[6]*x[3]*y[7]/12.0+z[6]*x[7]*y[4]/12.0-z[6]*x[4]*y[7]/12.0-z[6]*
+x[7]*y[3]/12.0+y[6]*x[5]*z[7]/12.0-y[6]*x[7]*z[5]/12.0-x[2]*y[5]*z[6]/12.0+z[6]
+*x[2]*y[7]/12.0+z[6]*x[7]*y[5]/12.0-z[6]*x[5]*y[7]/12.0-z[6]*x[7]*y[2]/12.0+x
+[6]*y[7]*z[5]/12.0+z[5]*x[7]*y[4]/12.0-z[5]*x[4]*y[7]/12.0+y[5]*x[1]*z[4]/12.0-
+y[5]*x[6]*z[4]/12.0-y[5]*x[4]*z[1]/12.0+y[5]*x[4]*z[6]/12.0;
+  s3 = y[6]*x[7]*z[3]/12.0+x[6]*y[5]*z[2]/12.0-x[5]*y[6]*z[2]/12.0-x[6]*y
+[2]*z[5]/12.0+x[5]*y[2]*z[6]/12.0+x[6]*y[2]*z[7]/12.0+z[5]*x[4]*y[0]/12.0-y[6]*
+x[2]*z[7]/12.0+x[2]*y[6]*z[5]/12.0+y[6]*x[7]*z[2]/12.0-y[6]*x[3]*z[7]/12.0-x[7]
+*y[4]*z[3]/12.0-x[6]*y[4]*z[7]/12.0-x[5]*y[1]*z[4]/12.0+x[6]*y[7]*z[4]/12.0+x
+[7]*y[3]*z[4]/12.0-z[1]*x[5]*y[6]/12.0+x[3]*y[4]*z[7]/12.0+x[5]*y[6]*z[4]/12.0;
+  
+  return s3+x[5]*y[4]*z[1]/12.0-x[5]*y[4]*z[6]/12.0-x[3]*y[7]*z[4]/12.0+x[6]*
+y[3]*z[7]/12.0-y[1]*x[6]*z[5]/12.0-z[5]*x[1]*y[4]/12.0+z[5]*x[6]*y[4]/12.0+z[5]
+*x[4]*y[1]/12.0-z[5]*x[4]*y[6]/12.0-x[6]*y[7]*z[3]/12.0-x[4]*y[3]*z[7]/12.0+x
+[4]*y[7]*z[3]/12.0-x[1]*y[5]*z[6]/12.0-y[6]*x[7]*z[4]/12.0-y[1]*x[2]*z[6]/12.0-
+y[2]*x[3]*z[6]/12.0+s2+s1+x[2]*y[0]*z[3]/12.0;
+};
+
+#endif
+
+
+template <int dim>
+unsigned int HexAccessor<dim>::number_of_children () const {
+  if (!has_children())
+    return 1;
+  else
+    {
+      unsigned int sum = 0;
+      for (unsigned int c=0; c<8; ++c)
+       sum += child(c)->number_of_children();
+      return sum;
+    };
+};
+
+
+
+
 
 /*------------------------ Functions: CellAccessor<1> -----------------------*/
 
@@ -872,6 +1949,49 @@ CellAccessor<2>::face (const unsigned int i) const {
 #endif
 
 
+
+/*------------------------ Functions: CellAccessor<3> -----------------------*/
+
+
+#if deal_II_dimension == 3
+
+template <>
+bool CellAccessor<3>::at_boundary () const {
+  return (at_boundary(0) || at_boundary(1) ||
+         at_boundary(2) || at_boundary(3) ||
+         at_boundary(4) || at_boundary(5));
+};
+
+
+
+template <>
+unsigned char CellAccessor<3>::material_id () const {
+  Assert (used(),
+         typename TriaSubstructAccessor<3>::ExcCellNotUsed());
+  return tria->levels[present_level]->hexes.material_id[present_index];
+};
+
+
+
+template <>
+void CellAccessor<3>::set_material_id (const unsigned char mat_id) const {
+  Assert (used(),
+         typename TriaSubstructAccessor<3>::ExcCellNotUsed());
+  tria->levels[present_level]->hexes.material_id[present_index]
+    = mat_id;                                           
+};
+
+
+
+template <>
+Triangulation<3>::face_iterator
+CellAccessor<3>::face (const unsigned int i) const {
+  return quad(i);
+};
+
+#endif
+
+
 /*------------------------ Functions: CellAccessor<dim> -----------------------*/
 
 
@@ -1050,6 +2170,13 @@ template class TriaIterator<deal_II_dimension,QuadAccessor<deal_II_dimension> >;
 template class TriaActiveIterator<deal_II_dimension,QuadAccessor<deal_II_dimension> >;
 #endif
 
+#if deal_II_dimension >= 3
+template class HexAccessor<deal_II_dimension>;
+template class TriaRawIterator<deal_II_dimension,HexAccessor<deal_II_dimension> >;
+template class TriaIterator<deal_II_dimension,HexAccessor<deal_II_dimension> >;
+template class TriaActiveIterator<deal_II_dimension,HexAccessor<deal_II_dimension> >;
+#endif
+
 
 
 
index 64f0e364092bfa1a464e67c3a678dbee5792db8b..7d21d33eb58c6174be5f5e813bfef9a7b7107535 100644 (file)
@@ -3,6 +3,41 @@
 
 
 #include <grid/tria_boundary.h>
+#include <cmath>
+
+
+
+template <int dim>
+Boundary<dim>::~Boundary ()
+{};
+
+
+template <int dim>
+Point<dim> StraightBoundary<dim>::in_between (const PointArray &neighbors) const 
+{
+  Point<dim> p;
+  for (int i=0; i<(1<<(dim-1)); ++i)
+    p += *neighbors[i];
+  p /= (1<<(dim-1))*1.0;
+  return p;
+};
+
+
+
+template <int dim>
+Point<dim> HyperBallBoundary<dim>::in_between (const PointArray &neighbors) const
+{
+  Point<dim> middle = StraightBoundary<dim>::in_between(neighbors);
+  
+  middle -= center;
+                                  // project to boundary
+  middle *= radius / sqrt(middle.square());
+  
+  middle += center;
+  return middle;
+};
+
+
 
 
 // explicit instantiations
index f286ffced1280ed859d9fa390f8bcae9bff9c72a..6b6adfcedad3b7aba9f2a5bf48ad9e8ed633b29a 100644 (file)
@@ -23,7 +23,6 @@
 
 
 
-
 template <int dim>
 ProblemBase<dim>::ProblemBase () :
                tria(0),
index 0e001ab7dcc4abd185b44d2c05767a7697a2082b..e3670b04716dca17930019c392a5cc7287da07ac 100644 (file)
@@ -506,6 +506,10 @@ void DataOut<dim>::write_gnuplot (ostream &out, unsigned int accuracy) const
          case 2:
                out << "<x> <y> ";
                break;
+         case 3:
+               out << "<x> <y> <z>";
+               break;
+               
          default:
                Assert (false, ExcNotImplemented());
        };
@@ -543,7 +547,7 @@ void DataOut<dim>::write_gnuplot (ostream &out, unsigned int accuracy) const
        {
          case 1:
                                                 // one dimension: write
-                                                // left vertex, right vertex
+                                                // each vertex, right vertex
                                                 // and data values
                for (supp_pt = 0; supp_pt<points.n_quadrature_points; ++supp_pt) 
                  {
@@ -560,8 +564,8 @@ void DataOut<dim>::write_gnuplot (ostream &out, unsigned int accuracy) const
          case 2:
                                                 // two dimension: output
                                                 // grid and data as a sequence
-                                                // of lines in 3d
-               
+                                                // of points in 3d forming
+                                                // a tensor mesh on each cell
                for (unsigned xpt = 0, supp_pt = 0;
                     xpt <= accuracy; ++xpt)
                {
@@ -580,6 +584,41 @@ void DataOut<dim>::write_gnuplot (ostream &out, unsigned int accuracy) const
                
                break;
 
+         case 3:
+                                                // three dimension: output
+                                                // grid and data as a tensor
+                                                // mesh in 4d. we very
+                                                // obviously have a problem
+                                                // here since humans can watch
+                                                // 4d lines properly. but one
+                                                // can at least view cuts
+                                                // through this hypercube,
+                                                // which is possible this
+                                                // way
+               
+               for (unsigned xpt = 0, supp_pt = 0;
+                    xpt <= accuracy; ++xpt)
+                 {
+                   for(unsigned ypt = 0; ypt <= accuracy; ++ypt)
+                     {
+                       for(unsigned zpt = 0; zpt <= accuracy; ++zpt, ++supp_pt)
+                         {
+                           Point<dim> pt = fe.quadrature_point(supp_pt);
+                           out << pt << "  ";
+                           
+                           for (unsigned int i=0; i!=data.size(); ++i)
+                             out << values[i][supp_pt]
+                                 << ' ';
+                           out << endl;
+                         }
+                       out << endl;
+                     }
+                   out << endl;
+                 };
+               
+               
+               break;
+
          default:
                Assert (false, ExcNotImplemented());
        }
@@ -701,6 +740,7 @@ void DataOut<dim>::write_gnuplot_draft (ostream &out) const
 };
 
 
+#if deal_II_dimension == 2
 
 template <>
 void DataOut<2>::write_povray_mesh (ostream &out) const {
@@ -804,6 +844,24 @@ void DataOut<2>::write_povray_mesh (ostream &out) const {
   AssertThrow (out, ExcIO());
 };
 
+
+#endif
+
+
+
+#if deal_II_dimension == 3
+
+template <>
+void DataOut<3>::write_povray_mesh (ostream &out) const {
+  Assert (false, ExcNotImplemented());
+};
+
+#endif
+
+
+
+#if deal_II_dimension == 2
+
 template <>
 void DataOut<2>::write_epsgrid (ostream &out) const {
   Assert (dofs != 0, ExcNoDoFHandlerSelected());
@@ -872,7 +930,9 @@ void DataOut<2>::write_epsgrid (ostream &out) const {
 
   AssertThrow (out, ExcIO());
 };
-      
+
+
+
 template <>
 void DataOut<2>::write_eps (ostream &out) const {
   Assert (dofs != 0, ExcNoDoFHandlerSelected());
@@ -965,6 +1025,24 @@ void DataOut<2>::write_eps (ostream &out) const {
   AssertThrow (out, ExcIO());
 };
 
+#endif
+
+
+#if deal_II_dimension == 3
+
+template <>
+void DataOut<3>::write_epsgrid (ostream &/*out*/) const {
+  Assert (false, ExcNotImplemented());
+};
+
+
+template <>
+void DataOut<3>::write_eps (ostream &/*out*/) const {
+  Assert (false, ExcNotImplemented());
+};
+
+#endif
+
 
 template <int dim>
 void DataOut<dim>::write (ostream &out,

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.