// clang-format off
/* ----------------------------------------------------------------------
   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
   https://www.lammps.org/ Sandia National Laboratories
   LAMMPS development team: developers@lammps.org

   Copyright (2003) Sandia Corporation.  Under the terms of Contract
   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
   certain rights in this software.  This software is distributed under
   the GNU General Public License.

   See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */

/* ----------------------------------------------------------------------
   Contributing authors: Ngoc Cuong Nguyen (MIT)
------------------------------------------------------------------------- */

// LAMMPS header files

#include "comm.h"
#include "error.h"
#include "math_const.h"
#include "math_special.h"
#include "memory.h"
#include "tokenizer.h"

#include <cmath>

// header file. Moved down here to avoid polluting other headers with its defines
#include "eapod.h"

using namespace LAMMPS_NS;
using MathConst::MY_PI;
using MathSpecial::cube;
using MathSpecial::powint;

static constexpr int MAXLINE=1024;

// constructor
EAPOD::EAPOD(LAMMPS *_lmp, const std::string &pod_file, const std::string &coeff_file) :
    Pointers(_lmp), elemindex(nullptr), Phi(nullptr), Lambda(nullptr), coeff(nullptr),
    tmpmem(nullptr), Proj(nullptr), Centroids(nullptr), bd(nullptr), bdd(nullptr), pd(nullptr),
    pdd(nullptr), pn3(nullptr), pq3(nullptr), pc3(nullptr), pq4(nullptr), pa4(nullptr),
    pb4(nullptr), pc4(nullptr), tmpint(nullptr), ind23(nullptr), ind32(nullptr), ind33(nullptr),
    ind34(nullptr), ind43(nullptr), ind44(nullptr), ind33l(nullptr), ind33r(nullptr),
    ind34l(nullptr), ind34r(nullptr), ind44l(nullptr), ind44r(nullptr)
{
  rin = 0.5;
  rcut = 5.0;
  nClusters = 1;
  nComponents = 1;
  nelements = 1;
  onebody = 1;
  besseldegree = 4;
  inversedegree = 8;
  nbesselpars = 3;
  true4BodyDesc = 1;
  ns = nbesselpars*besseldegree + inversedegree;
  Njmax = 100;
  nrbf2 = 8;
  nrbf3 = 6;
  nrbf4 = 4;
  nabf3 = 5;
  nabf4 = 3;
  nrbf23 = 0;
  nabf23 = 0;
  nrbf33 = 0;
  nabf33 = 0;
  nrbf34 = 0;
  nabf34 = 0;
  nabf43 = 0;
  nrbf44 = 0;
  nabf44 = 0;
  P3 = 4;
  P4 = 3;
  P23 = 0;
  P33 = 0;
  P34 = 0;
  P44 = 0;
  pdegree[0] = besseldegree;
  pdegree[1] = inversedegree;
  pbc[0] = 1;
  pbc[1] = 1;
  pbc[2] = 1;
  besselparams[0] = 1e-3;
  besselparams[1] = 2.0;
  besselparams[2] = 4.0;

  // read pod input file to podstruct
  read_pod_file(pod_file);

  if (coeff_file != "") {
    read_model_coeff_file(coeff_file);
  }
}

// destructor
EAPOD::~EAPOD()
{
  memory->destroy(elemindex);
  memory->destroy(Phi);
  memory->destroy(Lambda);
  memory->destroy(Proj);
  memory->destroy(Centroids);
  memory->destroy(bd);
  memory->destroy(bdd);
  memory->destroy(pd);
  memory->destroy(pdd);
  memory->destroy(coeff);
  memory->destroy(tmpmem);
  memory->destroy(tmpint);
  memory->destroy(pn3);
  memory->destroy(pq3);
  memory->destroy(pc3);
  memory->destroy(pa4);
  memory->destroy(pb4);
  memory->destroy(pc4);
  memory->destroy(pq4);
  memory->destroy(ind23);
  memory->destroy(ind32);
  memory->destroy(ind33);
  memory->destroy(ind34);
  memory->destroy(ind43);
  memory->destroy(ind44);
  memory->destroy(ind33l);
  memory->destroy(ind34l);
  memory->destroy(ind44l);
  memory->destroy(ind33r);
  memory->destroy(ind34r);
  memory->destroy(ind44r);
}

void EAPOD::read_pod_file(std::string pod_file)
{
  std::string podfilename = pod_file;
  FILE *fppod;
  if (comm->me == 0) {

    fppod = utils::open_potential(podfilename,lmp,nullptr);
    if (fppod == nullptr)
      error->one(FLERR,"Cannot open POD coefficient file {}: ",
                                   podfilename, utils::getsyserror());
  }

  // loop through lines of POD file and parse keywords

  char line[MAXLINE],*ptr;
  int eof = 0;

  while (true) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fppod);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fppod);
      }
    }
    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof) break;
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    // words = ptrs to all words in line
    // strip single and double quotes from words

    std::vector<std::string> words;
    try {
      words = Tokenizer(utils::trim_comment(line),"\"' \t\n\r\f").as_vector();
    } catch (TokenizerException &) {
      // ignore
    }

    if (words.size() == 0) continue;

    auto keywd = words[0];

    if (keywd == "species") {
      nelements = words.size()-1;
      for (int ielem = 1; ielem <= nelements; ielem++) {
        species.push_back(words[ielem]);
      }
    }

    if (keywd == "pbc") {
      if (words.size() != 4)
        error->one(FLERR,"Improper POD file.", utils::getsyserror());
      pbc[0] = utils::inumeric(FLERR,words[1],false,lmp);
      pbc[1] = utils::inumeric(FLERR,words[2],false,lmp);
      pbc[2] = utils::inumeric(FLERR,words[3],false,lmp);
    }

    if ((keywd != "#") && (keywd != "species") && (keywd != "pbc")) {

      if (words.size() != 2)
        error->one(FLERR,"Improper POD file.", utils::getsyserror());

      if (keywd == "rin") rin = utils::numeric(FLERR,words[1],false,lmp);
      if (keywd == "rcut") rcut = utils::numeric(FLERR,words[1],false,lmp);
      if (keywd == "number_of_environment_clusters")
        nClusters = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "number_of_principal_components")
        nComponents = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "bessel_polynomial_degree")
        besseldegree = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "inverse_polynomial_degree")
        inversedegree = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "onebody") onebody = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "twobody_number_radial_basis_functions")
        nrbf2 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "threebody_number_radial_basis_functions")
        nrbf3 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "threebody_angular_degree")
        P3 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "fourbody_number_radial_basis_functions")
        nrbf4 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "fourbody_angular_degree")
        P4 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "fivebody_number_radial_basis_functions")
        nrbf33 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "fivebody_angular_degree")
        P33 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "sixbody_number_radial_basis_functions")
        nrbf34 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "sixbody_angular_degree")
        P34 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "sevenbody_number_radial_basis_functions")
        nrbf44 = utils::inumeric(FLERR,words[1],false,lmp);
      if (keywd == "sevenbody_angular_degree")
        P44 = utils::inumeric(FLERR,words[1],false,lmp);
    }
  }
  if (nrbf3 < nrbf4) error->all(FLERR,"number of four-body radial basis functions must be equal or less than number of three-body radial basis functions");
  if (nrbf4 < nrbf33) error->all(FLERR,"number of five-body radial basis functions must be equal or less than number of four-body radial basis functions");
  if (nrbf4 < nrbf34) error->all(FLERR,"number of six-body radial basis functions must be equal or less than number of four-body radial basis functions");
  if (nrbf4 < nrbf44) error->all(FLERR,"number of seven-body radial basis functions must be equal or less than number of four-body radial basis functions");
  nrbfmax = (nrbf2 < nrbf3) ? nrbf3 : nrbf2;
  nrbfmax = (nrbfmax < nrbf4) ? nrbf4 : nrbfmax;
  nrbfmax = (nrbfmax < nrbf33) ? nrbf33 : nrbfmax;
  nrbfmax = (nrbfmax < nrbf34) ? nrbf34 : nrbfmax;
  nrbfmax = (nrbfmax < nrbf44) ? nrbf44 : nrbfmax;

  if (P3 < P4) error->all(FLERR,"four-body angular degree must be equal or less than three-body angular degree");
  if (P4 < P33) error->all(FLERR,"five-body angular degree must be equal or less than four-body angular degree");
  if (P4 < P34) error->all(FLERR,"six-body angular degree must be equal or less than four-body angular degree");
  if (P4 < P44) error->all(FLERR,"seven-body angular degree must be equal or less than four-body angular degree");

  if (P3 > 12) error->all(FLERR,"three-body angular degree must be equal or less than 12");
  if (P4 > 6) error->all(FLERR,"four-body angular degree must be equal or less than 6");

  int Ne = nelements;
  memory->create(elemindex, Ne*Ne, "elemindex");
  int k = 0;
  for (int i1 = 0; i1<Ne; i1++)
    for (int i2 = i1; i2<Ne; i2++) {
      elemindex[i2 + Ne*i1] = k;
      elemindex[i1 + Ne*i2] = k;
      k += 1;
    }

  init2body();
  init3body(P3);
  init4body(P4);

  int nb[] = {1,     2,     4,     7,    11,    16,    23};
  nabf33 = P33+1;
  nabf34 = P34+1;
  nabf43 = nb[P34];
  nabf44 = nb[P44];

  if (onebody==0)
    nd1 = 0;
  else
    nd1 = Ne;

  nl1 = nd1/Ne;
  nl2 = nrbf2*Ne;
  nl3 = nabf3*nrbf3*Ne*(Ne+1)/2;
  nl4 = nabf4*nrbf4*Ne*(Ne+1)*(Ne+2)/6;

  nd2 = nl2*Ne;
  nd3 = nl3*Ne;
  nd4 = nl4*Ne;

  n23 = nrbf23*Ne;
  n32 = nabf23*nrbf23*Ne*(Ne+1)/2;
  n33 = nabf33*nrbf33*Ne*(Ne+1)/2;
  n34 = nabf34*nrbf34*Ne*(Ne+1)/2;
  n43 = nabf43*nrbf34*Ne*(Ne+1)*(Ne+2)/6;
  n44 = nabf44*nrbf44*Ne*(Ne+1)*(Ne+2)/6;

  nl23 = n23*n32;
  nl34 = n34*n43;
  nl33 = n33*(n33+1)/2;
  nl44 = n44*(n44+1)/2;

  nd23 = nl23*Ne;
  nd33 = nl33*Ne;
  nd34 = nl34*Ne;
  nd44 = nl44*Ne;

  memory->create(ind23, n23, "ind23");
  memory->create(ind32, n32, "ind32");
  memory->create(ind33, n33, "ind33");
  memory->create(ind34, n34, "ind34");
  memory->create(ind43, n43, "ind43");
  memory->create(ind44, n44, "ind44");

  indexmap3(ind23, 1, nrbf23, Ne, 1, nrbf2);
  indexmap3(ind32, nabf23, nrbf23, Ne*(Ne+1)/2, nabf3, nrbf3);
  indexmap3(ind33, nabf33, nrbf33, Ne*(Ne+1)/2, nabf3, nrbf3);
  indexmap3(ind34, nabf34, nrbf34, Ne*(Ne+1)/2, nabf3, nrbf3);
  indexmap3(ind43, nabf43, nrbf34, Ne*(Ne+1)*(Ne+2)/6, nabf4, nrbf4);
  indexmap3(ind44, nabf44, nrbf44, Ne*(Ne+1)*(Ne+2)/6, nabf4, nrbf4);

  nld33 = 0;
  nld34 = 0;
  nld44 = 0;
  int nebf3 = Ne*(Ne+1)/2;
  int nebf4 = Ne*(Ne+1)*(Ne+2)/6;
  int dabf3[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
  int dabf4[] = {0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6};
  if (nrbf33>0) {
    nld33 = crossindices(dabf3, nabf3, nrbf3, nebf3, dabf3, nabf3, nrbf3, nebf3, P33, nrbf33);
    memory->create(ind33l, nld33, "ind33l");
    memory->create(ind33r, nld33, "ind33r");
    crossindices(ind33l, ind33r, dabf3, nabf3, nrbf3, nebf3, dabf3, nabf3, nrbf3, nebf3, P33, nrbf33);
  }
  if (nrbf34>0) {
    nld34 = crossindices(dabf3, nabf3, nrbf3, nebf3, dabf4, nabf4, nrbf4, nebf4, P34, nrbf34);
    memory->create(ind34l, nld34, "ind34l");
    memory->create(ind34r, nld34, "ind34r");
    crossindices(ind34l, ind34r, dabf3, nabf3, nrbf3, nebf3, dabf4, nabf4, nrbf4, nebf4, P34, nrbf34);
  }
  if (nrbf44>0) {
    nld44 = crossindices(dabf4, nabf4, nrbf4, nebf4, dabf4, nabf4, nrbf4, nebf4, P44, nrbf44);
    memory->create(ind44l, nld44, "ind44l");
    memory->create(ind44r, nld44, "ind44r");
    crossindices(ind44l, ind44r, dabf4, nabf4, nrbf4, nebf4, dabf4, nabf4, nrbf4, nebf4, P44, nrbf44);
  }
  ngd33 = nld33*Ne;
  ngd34 = nld34*Ne;
  ngd44 = nld44*Ne;
  nl33 = nld33;
  nl34 = nld34;
  nl44 = nld44;
  nd33 = ngd33;
  nd34 = ngd34;
  nd44 = ngd44;

  Mdesc = nl2 + nl3 + nl4 + nl23 + nl33 + nl34 + nl44;
  nl = nl1 + nl2 + nl3 + nl4 + nl23 + nl33 + nl34 + nl44;
  nd = nd1 + nd2 + nd3 + nd4 + nd23 + nd33 + nd34 + nd44;
  nCoeffPerElement = nl1 + Mdesc*nClusters;
  nCoeffAll = nCoeffPerElement*nelements;

  allocate_temp_memory(Njmax);

  if (comm->me == 0) {
    utils::logmesg(lmp, "**************** Begin of POD Potentials ****************\n");
    utils::logmesg(lmp, "species: ");
    for (int i=0; i<nelements; i++)
      utils::logmesg(lmp, "{} ", species[i]);
    utils::logmesg(lmp, "\n");
    utils::logmesg(lmp, "periodic boundary conditions: {} {} {}\n", pbc[0], pbc[1], pbc[2]);
    utils::logmesg(lmp, "number of environment clusters: {}\n", nClusters);
    utils::logmesg(lmp, "number of principal compoments: {}\n", nComponents);
    utils::logmesg(lmp, "inner cut-off radius: {}\n", rin);
    utils::logmesg(lmp, "outer cut-off radius: {}\n", rcut);
    utils::logmesg(lmp, "bessel polynomial degree: {}\n", besseldegree);
    utils::logmesg(lmp, "inverse polynomial degree: {}\n",inversedegree);
    utils::logmesg(lmp, "one-body potential: {}\n", onebody);
    utils::logmesg(lmp, "two-body radial basis functions: {}\n", nrbf2);
    utils::logmesg(lmp, "three-body radial basis functions: {}\n", nrbf3);
    utils::logmesg(lmp, "three-body angular degree: {}\n", P3);
    if (P23 < P4) {
      utils::logmesg(lmp, "four-body radial basis functions: {}\n", nrbf4);
      utils::logmesg(lmp, "four-body angular degree: {}\n", P4);
    }
    else {
      utils::logmesg(lmp, "four-body radial basis functions: {}\n", nrbf23);
      utils::logmesg(lmp, "four-body angular degree: {}\n", P23);
    }
    utils::logmesg(lmp, "five-body radial basis functions: {}\n", nrbf33);
    utils::logmesg(lmp, "five-body angular degree: {}\n", P33);
    utils::logmesg(lmp, "six-body radial basis functions: {}\n", nrbf34);
    utils::logmesg(lmp, "six-body angular degree: {}\n", P34);
    utils::logmesg(lmp, "seven-body radial basis functions: {}\n", nrbf44);
    utils::logmesg(lmp, "seven-body angular degree: {}\n", P44);
    utils::logmesg(lmp, "number of local descriptors per element for one-body potential: {}\n", nl1);
    utils::logmesg(lmp, "number of local descriptors per element for two-body potential: {}\n", nl2);
    utils::logmesg(lmp, "number of local descriptors per element for three-body potential: {}\n", nl3);
    utils::logmesg(lmp, "number of local descriptors per element for four-body potential: {}\n", nl4+nl23);
    utils::logmesg(lmp, "number of local descriptors per element for five-body potential: {}\n", nl33);
    utils::logmesg(lmp, "number of local descriptors per element for six-body potential: {}\n", nl34);
    utils::logmesg(lmp, "number of local descriptors per element for seven-body potential: {}\n", nl44);
    utils::logmesg(lmp, "number of local descriptors per element for all potentials: {}\n", nl);
    utils::logmesg(lmp, "number of global descriptors: {}\n", nCoeffAll);
    utils::logmesg(lmp, "**************** End of POD Potentials ****************\n\n");
  }
}

void EAPOD::read_model_coeff_file(std::string coeff_file)
{
  std::string coefffilename = coeff_file;
  FILE *fpcoeff;
  if (comm->me == 0) {

    fpcoeff = utils::open_potential(coefffilename,lmp,nullptr);
    if (fpcoeff == nullptr)
      error->one(FLERR,"Cannot open model coefficient file {}: ", coefffilename, utils::getsyserror());
  }

  // check format for first line of file

  char line[MAXLINE],*ptr;
  int eof = 0;
  int nwords = 0;
  while (nwords == 0) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpcoeff);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpcoeff);
      }
    }
    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof) break;
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    // strip comment, skip line if blank
    nwords = utils::count_words(utils::trim_comment(line));
  }

  if (nwords != 4)
    error->all(FLERR,"Incorrect format in POD coefficient file");

  // strip single and double quotes from words

  int ncoeffall, nprojall, ncentall;
  std::string tmp_str;
  try {
    ValueTokenizer words(utils::trim_comment(line),"\"' \t\n\r\f");
    tmp_str = words.next_string();
    ncoeffall = words.next_int();
    nprojall = words.next_int();
    ncentall = words.next_int();
  } catch (TokenizerException &e) {
    error->all(FLERR,"Incorrect format in POD coefficient file: {}", e.what());
  }

  // loop over single block of coefficients and insert values in coeff

  memory->create(coeff, ncoeffall, "pod:pod_coeff");

  for (int icoeff = 0; icoeff < ncoeffall; icoeff++) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpcoeff);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpcoeff);
      }
    }

    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof) error->all(FLERR,"Incorrect format in model coefficient file");
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    try {
      ValueTokenizer cff(utils::trim_comment(line));
      if (cff.count() != 1) error->all(FLERR,"Incorrect format in model coefficient file");

      coeff[icoeff] = cff.next_double();
    } catch (TokenizerException &e) {
      error->all(FLERR,"Incorrect format in model coefficient file: {}", e.what());
    }
  }

  memory->create(Proj, nprojall, "pod:pca_proj");

  for (int iproj = 0; iproj < nprojall; iproj++) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpcoeff);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpcoeff);
      }
    }

    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof) error->all(FLERR,"Incorrect format in model coefficient file");
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    try {
      ValueTokenizer cff(utils::trim_comment(line));
      if (cff.count() != 1) error->all(FLERR,"Incorrect format in model coefficient file");

      Proj[iproj] = cff.next_double();
    } catch (TokenizerException &e) {
      error->all(FLERR,"Incorrect format in model coefficient file: {}", e.what());
    }
  }

  memory->create(Centroids, ncentall, "pod:pca_cent");

  for (int icent = 0; icent < ncentall; icent++) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpcoeff);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpcoeff);
      }
    }

    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof) error->all(FLERR,"Incorrect format in model coefficient file");
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    try {
      ValueTokenizer cff(utils::trim_comment(line));
      if (cff.count() != 1) error->all(FLERR,"Incorrect format in model coefficient file");

      Centroids[icent] = cff.next_double();
    } catch (TokenizerException &e) {
      error->all(FLERR,"Incorrect format in model coefficient file: {}", e.what());
    }
  }

  if (comm->me == 0) {
    if (!eof) fclose(fpcoeff);
  }


  if (ncoeffall != nCoeffAll)
    error->all(FLERR,"number of coefficients in the coefficient file is not correct");

  if (nClusters > 1) {
    if (nprojall != nComponents*Mdesc*nelements)
      error->all(FLERR,"number of coefficients in the projection file is not correct");

    if (ncentall != nComponents*nClusters*nelements)
        error->all(FLERR,"number of coefficients in the projection file is not correct");
  }

  if (comm->me == 0) {
    utils::logmesg(lmp, "**************** Begin of Model Coefficients ****************\n");
    utils::logmesg(lmp, "total number of coefficients for POD potential: {}\n", ncoeffall);
    utils::logmesg(lmp, "total number of elements for PCA projection matrix: {}\n", nprojall);
    utils::logmesg(lmp, "total number of elements for PCA centroids: {}\n", ncentall);
    utils::logmesg(lmp, "**************** End of Model Coefficients ****************\n\n");
  }
}

int EAPOD::read_coeff_file(std::string coeff_file)
{
  std::string coefffilename = coeff_file;
  FILE *fpcoeff;
  if (comm->me == 0) {

    fpcoeff = utils::open_potential(coefffilename,lmp,nullptr);
    if (fpcoeff == nullptr)
      error->one(FLERR,"Cannot open POD coefficient file {}: ",
                                   coefffilename, utils::getsyserror());
  }

  // check format for first line of file

  char line[MAXLINE],*ptr;
  int eof = 0;
  int nwords = 0;
  while (nwords == 0) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpcoeff);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpcoeff);
      }
    }
    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof) break;
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    // strip comment, skip line if blank

    nwords = utils::count_words(utils::trim_comment(line));
  }

  if (nwords != 2)
    error->all(FLERR,"Incorrect format in POD coefficient file");

  // strip single and double quotes from words

  int ncoeffall;
  std::string tmp_str;
  try {
    ValueTokenizer words(utils::trim_comment(line),"\"' \t\n\r\f");
    tmp_str = words.next_string();
    ncoeffall = words.next_int();
  } catch (TokenizerException &e) {
    error->all(FLERR,"Incorrect format in POD coefficient file: {}", e.what());
  }

  // loop over single block of coefficients and insert values in coeff

  memory->create(coeff, ncoeffall, "pod:pod_coeff");

  for (int icoeff = 0; icoeff < ncoeffall; icoeff++) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpcoeff);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpcoeff);
      }
    }

    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof)
      error->all(FLERR,"Incorrect format in POD coefficient file");
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    try {
      ValueTokenizer cff(utils::trim_comment(line));
      if (cff.count() != 1)
        error->all(FLERR,"Incorrect format in POD coefficient file");

      coeff[icoeff] = cff.next_double();
    } catch (TokenizerException &e) {
      error->all(FLERR,"Incorrect format in POD coefficient file: {}", e.what());
    }
  }

  if (comm->me == 0) {
    if (!eof) fclose(fpcoeff);
  }

  if (comm->me == 0) {
    utils::logmesg(lmp, "**************** Begin of POD Coefficients ****************\n");
    utils::logmesg(lmp, "total number of coefficients for POD potential: {}\n", ncoeffall);
    utils::logmesg(lmp, "**************** End of POD Coefficients ****************\n\n");
  }

  return ncoeffall;
}

// funcion to read the projection matrix from file.
int EAPOD::read_projection_matrix(std::string proj_file)
{
  std::string projfilename = proj_file;
  FILE *fpproj;
  if (comm->me == 0) {

    fpproj = utils::open_potential(projfilename,lmp,nullptr);
    if (fpproj == nullptr)
      error->one(FLERR,"Cannot open PCA projection matrix file {}: ",
                                   projfilename, utils::getsyserror());
  }

  // check format for first line of file

  char line[MAXLINE],*ptr;
  int eof = 0;
  int nwords = 0;
  while (nwords == 0) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpproj);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpproj);
      }
    }
    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof) break;
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    // strip comment, skip line if blank

    nwords = utils::count_words(utils::trim_comment(line));
  }

  if (nwords != 2)
    error->all(FLERR,"Incorrect format in PCA projection matrix file");

  // strip single and double quotes from words

  int nprojall;
  std::string tmp_str;
  try {
    ValueTokenizer words(utils::trim_comment(line),"\"' \t\n\r\f");
    tmp_str = words.next_string();
    nprojall = words.next_int();
  } catch (TokenizerException &e) {
    error->all(FLERR,"Incorrect format in PCA projection matrix file: {}", e.what());
  }

  // loop over single block of coefficients and insert values in coeff

  memory->create(Proj, nprojall, "pod:pca_proj");

  for (int iproj = 0; iproj < nprojall; iproj++) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpproj);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpproj);
      }
    }

    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof)
      error->all(FLERR,"Incorrect format in PCA projection matrix file");
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    try {
      ValueTokenizer cff(utils::trim_comment(line));
      if (cff.count() != 1)
        error->all(FLERR,"Incorrect format in PCA projection matrix file");

      Proj[iproj] = cff.next_double();
    } catch (TokenizerException &e) {
      error->all(FLERR,"Incorrect format in PCA projection matrix file: {}", e.what());
    }
  }
  if (comm->me == 0) {
    if (!eof) fclose(fpproj);
  }

  if (comm->me == 0) {
    utils::logmesg(lmp, "**************** Begin of PCA projection matrix ****************\n");
    utils::logmesg(lmp, "total number of elements for PCA projection matrix: {}\n", nprojall);
    utils::logmesg(lmp, "**************** End of PCA projection matrix ****************\n\n");
  }

  return nprojall;
}

// read Centroids from file
int EAPOD::read_centroids(std::string centroids_file)
{
  std::string centfilename = centroids_file;
  FILE *fpcent;
  if (comm->me == 0) {

    fpcent = utils::open_potential(centfilename,lmp,nullptr);
    if (fpcent == nullptr)
      error->one(FLERR,"Cannot open PCA centroids file {}: ",
                                   centfilename, utils::getsyserror());
  }

  // check format for first line of file

  char line[MAXLINE],*ptr;
  int eof = 0;
  int nwords = 0;
  while (nwords == 0) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpcent);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpcent);
      }
    }
    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof) break;
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    // strip comment, skip line if blank

    nwords = utils::count_words(utils::trim_comment(line));
  }

  if (nwords != 2)
    error->all(FLERR,"Incorrect format in PCA centroids file");

  // strip single and double quotes from words

  int ncentall;
  std::string tmp_str;
  try {
    ValueTokenizer words(utils::trim_comment(line),"\"' \t\n\r\f");
    tmp_str = words.next_string();
    ncentall = words.next_int();
  } catch (TokenizerException &e) {
    error->all(FLERR,"Incorrect format in PCA centroids file: {}", e.what());
  }

  // loop over single block of coefficients and insert values in coeff

  memory->create(Centroids, ncentall, "pod:pca_cent");

  for (int icent = 0; icent < ncentall; icent++) {
    if (comm->me == 0) {
      ptr = fgets(line,MAXLINE,fpcent);
      if (ptr == nullptr) {
        eof = 1;
        fclose(fpcent);
      }
    }

    MPI_Bcast(&eof,1,MPI_INT,0,world);
    if (eof)
      error->all(FLERR,"Incorrect format in PCA centroids file");
    MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);

    try {
      ValueTokenizer cff(utils::trim_comment(line));
      if (cff.count() != 1)
        error->all(FLERR,"Incorrect format in PCA centroids file");

      Centroids[icent] = cff.next_double();
    } catch (TokenizerException &e) {
      error->all(FLERR,"Incorrect format in PCA centroids file: {}", e.what());
    }
  }
  if (comm->me == 0) {
    if (!eof) fclose(fpcent);
  }

  if (comm->me == 0) {
    utils::logmesg(lmp, "**************** Begin of PCA centroids ****************\n");
    utils::logmesg(lmp, "total number of elements for PCA centroids: {}\n", ncentall);
    utils::logmesg(lmp, "**************** End of PCA centroids ****************\n\n");
  }

  return ncentall;
}


void EAPOD::peratombase_descriptors(double *bd1, double *bdd1, double *rij, double *temp,
        int *tj, int Nj)
{
  for (int i=0; i<Mdesc; i++) bd1[i] = 0.0;
  for (int i=0; i<3*Nj*Mdesc; i++) bdd1[i] = 0.0;

  if (Nj == 0) return;

  double *d2 =  &bd1[0]; // nl2
  double *d3 =  &bd1[nl2]; // nl3
  double *d4 =  &bd1[nl2 + nl3]; // nl4
  double *d23 =  &bd1[nl2 + nl3 + nl4]; // nl23
  double *d33 =  &bd1[nl2 + nl3 + nl4 + nl23]; // nl33
  double *d34 =  &bd1[nl2 + nl3 + nl4 + nl23 + nl33]; // nl34
  double *d44 =  &bd1[nl2 + nl3 + nl4 + nl23 + nl33 + nl34]; // nl44

  double *dd2 = &bdd1[0]; // 3*Nj*nl2
  double *dd3 = &bdd1[3*Nj*nl2]; // 3*Nj*nl3
  double *dd4 = &bdd1[3*Nj*(nl2+nl3)]; // 3*Nj*nl4
  double *dd23 = &bdd1[3*Nj*(nl2+nl3+nl4)]; // 3*Nj*nl23
  double *dd33 = &bdd1[3*Nj*(nl2+nl3+nl4+nl23)]; // 3*Nj*nl33
  double *dd34 = &bdd1[3*Nj*(nl2+nl3+nl4+nl23+nl33)]; // 3*Nj*nl34
  double *dd44 = &bdd1[3*Nj*(nl2+nl3+nl4+nl23+nl33+nl34)]; // 3*Nj*nl44

  int n1 = Nj*K3*nrbf3;
  int n2 = Nj*nrbfmax;
  int n3 = Nj*ns;
  int n4 = Nj*K3;
  int n5 = K3*nrbf3*nelements;

  double *U = &temp[0]; // Nj*K3*nrbf3
  double *Ux = &temp[n1]; // Nj*K3*nrbf3
  double *Uy = &temp[2*n1]; // Nj*K3*nrbf3
  double *Uz = &temp[3*n1]; // Nj*K3*nrbf3
  double *sumU = &temp[4*n1]; // K3*nrbf3*nelements

  double *rbf = &temp[4*n1 + n5]; // Nj*nrbf2
  double *rbfx = &temp[4*n1 + n5 + n2]; // Nj*nrbf2
  double *rbfy = &temp[4*n1 + n5 + 2*n2]; // Nj*nrbf2
  double *rbfz = &temp[4*n1 + n5 + 3*n2]; // Nj*nrbf2

  double *rbft = &temp[4*n1 + n5 + 4*n2]; // Nj*ns
  double *rbfxt = &temp[4*n1 + n5 + 4*n2 + n3]; // Nj*ns
  double *rbfyt = &temp[4*n1 + n5 + 4*n2 + 2*n3]; // Nj*ns
  double *rbfzt = &temp[4*n1 + n5 + 4*n2 + 3*n3]; // Nj*ns

  radialbasis(rbft, rbfxt, rbfyt, rbfzt, rij, besselparams, rin, rcut-rin, pdegree[0], pdegree[1], nbesselpars, Nj);

  char chn = 'N';
  double alpha = 1.0, beta = 0.0;
  DGEMM(&chn, &chn, &Nj, &nrbfmax, &ns, &alpha, rbft, &Nj, Phi, &ns, &beta, rbf, &Nj);
  DGEMM(&chn, &chn, &Nj, &nrbfmax, &ns, &alpha, rbfxt, &Nj, Phi, &ns, &beta, rbfx, &Nj);
  DGEMM(&chn, &chn, &Nj, &nrbfmax, &ns, &alpha, rbfyt, &Nj, Phi, &ns, &beta, rbfy, &Nj);
  DGEMM(&chn, &chn, &Nj, &nrbfmax, &ns, &alpha, rbfzt, &Nj, Phi, &ns, &beta, rbfz, &Nj);

  if ((nl2>0) && (Nj>0)) {
    twobodydescderiv(d2, dd2, rbf, rbfx, rbfy, rbfz, tj, Nj);
  }

  if ((nl3 > 0) && (Nj>1)) {
    double *abf = &temp[4*n1 + n5 + 4*n2]; // Nj*K3
    double *abfx = &temp[4*n1 + n5 + 4*n2 + n4]; // Nj*K3
    double *abfy = &temp[4*n1 + n5 + 4*n2 + 2*n4]; // Nj*K3
    double *abfz = &temp[4*n1 + n5 + 4*n2 + 3*n4]; // Nj*K3
    double *tm = &temp[4*n1 + n5 + 4*n2 + 4*n4]; // 4*K3

    angularbasis(abf, abfx, abfy, abfz, rij, tm, pq3, Nj, K3);

    radialangularbasis(sumU, U, Ux, Uy, Uz, rbf, rbfx, rbfy, rbfz,
            abf, abfx, abfy, abfz, tj, Nj, K3, nrbf3, nelements);

    threebodydesc(d3, sumU);
    threebodydescderiv(dd3, sumU, Ux, Uy, Uz, tj, Nj);

    if ((nl23>0) && (Nj>2)) {
      fourbodydesc23(d23, d2, d3);
      fourbodydescderiv23(dd23, d2, d3, dd2, dd3, 3*Nj);
    }

    if ((nl33>0) && (Nj>3)) {
      crossdesc(d33, d3, d3, ind33l, ind33r, nl33);
      crossdescderiv(dd33, d3, d3, dd3, dd3, ind33l, ind33r, nl33, 3*Nj);
    }

    if ((nl4 > 0) && (Nj>2)) {
      if (K4 < K3) {
        for (int m=0; m<nrbf4; m++)
          for (int k=0; k<K4; k++)
            for (int i=0; i<nelements; i++)
              sumU[i + nelements*k + nelements*K4*m] = sumU[i + nelements*k + nelements*K3*m];

        for (int m=0; m<nrbf4; m++)
          for (int k=0; k<K4; k++)
            for (int i=0; i<Nj; i++) {
              int ii = i + Nj*k + Nj*K4*m;
              int jj = i + Nj*k + Nj*K3*m;
              Ux[ii] = Ux[jj];
              Uy[ii] = Uy[jj];
              Uz[ii] = Uz[jj];
            }
      }
      fourbodydescderiv(d4, dd4, sumU, Ux, Uy, Uz, tj, Nj);

      if ((nl34>0) && (Nj>4)) {
        crossdesc(d34, d3, d4, ind34l, ind34r, nl34);
        crossdescderiv(dd34, d3, d4, dd3, dd4, ind34l, ind34r, nl34, 3*Nj);
      }

      if ((nl44>0) && (Nj>5)) {
        crossdesc(d44, d4, d4, ind44l, ind44r, nl44);
        crossdescderiv(dd44, d4, d4, dd4, dd4, ind44l, ind44r, nl44, 3*Nj);
      }
    }
  }
}

double EAPOD::peratombase_coefficients(double *cb, double *bd, int *ti)
{
  int nc = nCoeffPerElement*(ti[0]-1);

  double ei = coeff[0 + nc];
  for (int m=0; m<Mdesc; m++) {
    ei += coeff[1 + m + nc]*bd[m];
    cb[m] = coeff[1 + m + nc];
  }

  return ei;
}

double EAPOD::peratom_environment_descriptors(double *cb, double *bd, double *tm, int *ti)
{
  double *P    = &tm[0];    // nClusters
  double *cp   = &tm[(nClusters)];  // nClusters
  double *D    = &tm[(2*nClusters)];   // nClusters
  double *pca  = &tm[(3*nClusters)]; // nComponents

  double *proj = &Proj[0];
  double *cent = &Centroids[0];
  int typei = ti[0]-1;

  for (int k=0; k<nComponents; k++) {
    double sum = 0.0;
    for (int m = 0; m < Mdesc; m++) {
      sum += proj[k + nComponents*m + nComponents*Mdesc*typei] * bd[m];
    }
    pca[k] = sum;
  }

  for (int j=0; j<nClusters; j++) {
    double sum = 1e-20;
    for (int k = 0; k < nComponents; k++) {
      double c = cent[k + j * nComponents + nClusters*nComponents*typei];
      double p = pca[k];
      sum += (p - c) * (p - c);
    }
    D[j] = 1.0 / sum;
  }

  double sum = 0.0;
  for (int j = 0; j < nClusters; j++) sum += D[j];
  double sumD = sum;
  if (sum != 0.0) {
    for (int j = 0; j < nClusters; j++) P[j] = D[j]/sum;
  } else {
    for (int j = 0; j < nClusters; j++) P[j] = 0.0;
  }

  int nc = nCoeffPerElement*(ti[0]-1);
  double ei = coeff[0 + nc];
  for (int k = 0; k<nClusters; k++)
    for (int m=0; m<Mdesc; m++)
      ei += coeff[1 + m + Mdesc*k + nc]*bd[m]*P[k];

  for (int k=0; k<nClusters; k++) {
    double sum = 0;
    for (int m = 0; m<Mdesc; m++)
      sum += coeff[1 + m + k*Mdesc + nc]*bd[m];
    cp[k] = sum;
  }

  for (int m = 0; m<Mdesc; m++) {
    double sum = 0.0;
    for (int k = 0; k<nClusters; k++)
      sum += coeff[1 + m + k*Mdesc + nc]*P[k];
    cb[m] = sum;
  }

  for (int m = 0; m<Mdesc; m++) {
    double S1 = 1.0/sumD;
    double S2 = S1*S1;
    double sum = 0.0;
    for (int j=0; j<nClusters; j++) {
      double dP_dB = 0.0;
      for (int k = 0; k < nClusters; k++) {
        double dP_dD = -D[j] * S2;
        if (k==j) dP_dD += S1;
        double dD_dB = 0.0;
        double D2 = 2 * D[k] * D[k];
        for (int n = 0; n < nComponents; n++) {
          double dD_dpca = D2 * (cent[n + k * nComponents + nClusters*nComponents*typei] - pca[n]);
          dD_dB += dD_dpca * proj[n + m * nComponents + nComponents*Mdesc*typei];
        }
        dP_dB += dP_dD * dD_dB;
      }
      sum += cp[j]*dP_dB;
    }
    cb[m] += sum;
  }

  return ei;
}

void EAPOD::twobody_forces(double *fij, double *cb2, double *rbfx, double *rbfy, double *rbfz, int *tj, int Nj)
{
  // Calculate the two-body descriptors and their derivatives
  int totalIterations = nrbf2 * Nj;
  for (int idx = 0; idx < totalIterations; idx++) {
    int n = idx / nrbf2; // Recalculate m
    int m = idx % nrbf2; // Recalculate n

    int i2 = n + Nj * m; // Index of the radial basis function for atom n and RBF m
    int i1 = 3*n;
    double c = cb2[m + nrbf2*(tj[n] - 1)];
    fij[0 + i1] += c*rbfx[i2]; // Add the derivative with respect to x to the corresponding descriptor derivative
    fij[1 + i1] += c*rbfy[i2]; // Add the derivative with respect to y to the corresponding descriptor derivative
    fij[2 + i1] += c*rbfz[i2]; // Add the derivative with respect to z to the corresponding descriptor derivative
  }
}

void EAPOD::threebody_forcecoeff(double *fb3, double *cb3, double *sumU)
{
  if (nelements==1) {
    for (int m = 0; m < nrbf3; ++m) {
      for (int p = 0; p < nabf3; p++) {
        double c3 = 2.0 * cb3[p + nabf3*m];
        int n1 = pn3[p];
        int n2 = pn3[p + 1];
        int nn = n2 - n1;
        int idxU = K3 * m;
        for (int q = 0; q < nn; q++) {
          int k = n1 + q;
          fb3[k + idxU] += c3 * pc3[k] * sumU[k + idxU];
        }
      }
    }
  }
  else {
    int N3 = nabf3 * nrbf3;
    for (int m = 0; m < nrbf3; ++m) {
      for (int p = 0; p < nabf3; p++) {
        int n1 = pn3[p];
        int n2 = pn3[p + 1];
        int nn = n2 - n1;
        int jmp = p + nabf3*m;
        for (int q = 0; q < nn; q++) {
          int k = n1 + q;  // Combine n1 and q into a single index
          int idxU = nelements * k + nelements * K3 * m;
          for (int i1 = 0; i1 < nelements; i1++) {
            double tm = pc3[k] * sumU[i1 + idxU];
            for (int i2 = i1; i2 < nelements; i2++) {
              int em = elemindex[i2 + nelements * i1];
              double t1 = tm * cb3[jmp + N3*em]; // Ni *  nabf3 * nrbf3 * nelements*(nelements+1)/2
              fb3[i2 + idxU] += t1;   // K3*nrbf3*Ni
              fb3[i1 + idxU] += pc3[k] * cb3[jmp + N3*em] * sumU[i2 + idxU];
            }
          }
        }
      }
    }
  }
}

void EAPOD::fourbody_forcecoeff(double *fb4, double *cb4, double *sumU)
{
  if (nelements==1) {
    for (int m = 0; m < nrbf4; ++m) {
      int idxU = K3 * m;
      for (int p = 0; p < nabf4; p++) {
        int n1 = pa4[p];
        int n2 = pa4[p + 1];
        int nn = n2 - n1;
        double c4 = cb4[p + nabf4*m];
        for (int q = 0; q < nn; q++) {
          int idxNQ = n1 + q;  // Combine n1 and q into a single index
          double c = c4 * pc4[idxNQ];
          int j1 = idxU + pb4[idxNQ];
          int j2 = idxU + pb4[idxNQ + Q4];
          int j3 = idxU + pb4[idxNQ + 2 * Q4];
          double c1 = sumU[j1];
          double c2 = sumU[j2];
          double c3 = sumU[j3];
          fb4[j3] += c * c1 * c2;
          fb4[j2] += c * c1 * c3;
          fb4[j1] += c * c2 * c3;
        }
      }
    }
  }
  else {
    int N3 = nabf4 * nrbf4;
    for (int m = 0; m < nrbf4; ++m) {
      for (int p = 0; p < nabf4; p++)  {
        int n1 = pa4[p];
        int n2 = pa4[p + 1];
        int nn = n2 - n1;
        int jpm = p + nabf4*m;
        for (int q = 0; q < nn; q++) {
          int c = pc4[n1 + q];
          int j1 = pb4[n1 + q];
          int j2 = pb4[n1 + q + Q4];
          int j3 = pb4[n1 + q + 2 * Q4];
          int idx1 = nelements * j1 + nelements * K3 * m;
          int idx2 = nelements * j2 + nelements * K3 * m;
          int idx3 = nelements * j3 + nelements * K3 * m;
          int k = 0;
          for (int i1 = 0; i1 < nelements; i1++) {
            double c1 = sumU[idx1 + i1];
            for (int i2 = i1; i2 < nelements; i2++) {
              double c2 = sumU[idx2 + i2];
              for (int i3 = i2; i3 < nelements; i3++) {
                double c3 = sumU[idx3 + i3];
                double c4 = c * cb4[jpm + N3*k];
                fb4[idx3 + i3] += c4*(c1 * c2);
                fb4[idx2 + i2] += c4*(c1 * c3);
                fb4[idx1 + i1] += c4*(c2 * c3);
                k += 1;
              }
            }
          }
        }
      }
    }
  }
}

void EAPOD::allbody_forces(double *fij, double *forcecoeff, double *rbf, double *rbfx, double *rbfy, double *rbfz,
        double *abf, double *abfx, double *abfy, double *abfz, int *tj, int Nj)
{
  int totalIterations = nrbf3 * Nj;
  for (int idx = 0; idx < totalIterations; ++idx) {
    int j = idx / nrbf3;  // Derive the original j value
    int m = idx % nrbf3;  // Derive the original m value
    int idxR = m + nrbfmax * j;  // Pre-compute the index for rbf
    int i2 = tj[j] - 1;
    double rbfBase = rbf[idxR];
    double rbfxBase = rbfx[idxR];
    double rbfyBase = rbfy[idxR];
    double rbfzBase = rbfz[idxR];
    double fx = 0;
    double fy = 0;
    double fz = 0;
    for (int k = 0; k < K3; k++) {
      int idxU = nelements * k + nelements * K3 * m;
      double fc = forcecoeff[i2 + idxU];
      int idxA = k + K3 * j;  // Pre-compute the index for abf
      double abfA = abf[idxA];
      double abfxA = abfx[idxA];
      double abfyA = abfy[idxA];
      double abfzA = abfz[idxA];
      fx += fc * (abfxA * rbfBase + rbfxBase * abfA); // K3*nrbf3*Nij
      fy += fc * (abfyA * rbfBase + rbfyBase * abfA);
      fz += fc * (abfzA * rbfBase + rbfzBase * abfA);
    }
    int baseIdx = 3 * j;
    fij[baseIdx]     += fx;
    fij[baseIdx + 1] += fy;
    fij[baseIdx + 2] += fz;
  }
}

void EAPOD::allbody_forces(double *fij, double *forcecoeff, double *Ux, double *Uy, double *Uz, int *tj, int Nj)
{
  for (int j = 0; j < Nj; ++j) {
    int i2 = tj[j] - 1;
    double fx = 0;
    double fy = 0;
    double fz = 0;
    for (int m = 0; m < nrbf3; m++)
      for (int k = 0; k < K3; k++) {
        double fc = forcecoeff[i2 + nelements * k + nelements * K3 * m];
        int idxU = j + Nj*k + Nj * K3 * m;  // Pre-compute the index for abf
        fx += fc * Ux[idxU]; // K3*nrbf3*Nij
        fy += fc * Uy[idxU];
        fz += fc * Uz[idxU];
      }
    int baseIdx = 3 * j;
    fij[baseIdx]     += fx;
    fij[baseIdx + 1] += fy;
    fij[baseIdx + 2] += fz;
  }
}

double EAPOD::peratomenergyforce2(double *fij, double *rij, double *temp,
        int *ti, int *tj, int Nj)
{
  if (Nj==0) {
    return coeff[nCoeffPerElement*(ti[0]-1)];
  }

  int N = 3*Nj;
  for (int n=0; n<N; n++) fij[n] = 0.0;

  //double *coeff1 = &coeff[nCoeffPerElement*(ti[0]-1)];
  double e = 0.0;
  for (int i=0; i<Mdesc; i++) bd[i] = 0.0;

  double *d2 =  &bd[0]; // nl2
  double *d3 =  &bd[nl2]; // nl3
  double *d4 =  &bd[nl2 + nl3]; // nl4
  double *d23 =  &bd[nl2 + nl3 + nl4]; // nl23
  double *d33 =  &bd[nl2 + nl3 + nl4 + nl23]; // nl33
  double *d34 =  &bd[nl2 + nl3 + nl4 + nl23 + nl33]; // nl34
  double *d44 =  &bd[nl2 + nl3 + nl4 + nl23 + nl33 + nl34]; // nl44

  int n1 = Nj*K3*nrbf3;
  int n2 = Nj*nrbfmax;
  int n3 = Nj*ns;
  int n4 = Nj*K3;
  int n5 = K3*nrbf3*nelements;

  double *U = &temp[0]; // Nj*K3*nrbf3
  double *Ux = &temp[n1]; // Nj*K3*nrbf3
  double *Uy = &temp[2*n1]; // Nj*K3*nrbf3
  double *Uz = &temp[3*n1]; // Nj*K3*nrbf3
  double *sumU = &temp[4*n1]; // K3*nrbf3*nelements

  double *rbf = &temp[4*n1 + n5]; // Nj*nrbf2
  double *rbfx = &temp[4*n1 + n5 + n2]; // Nj*nrbf2
  double *rbfy = &temp[4*n1 + n5 + 2*n2]; // Nj*nrbf2
  double *rbfz = &temp[4*n1 + n5 + 3*n2]; // Nj*nrbf2

  double *rbft = &temp[4*n1 + n5 + 4*n2]; // Nj*ns
  double *rbfxt = &temp[4*n1 + n5 + 4*n2 + n3]; // Nj*ns
  double *rbfyt = &temp[4*n1 + n5 + 4*n2 + 2*n3]; // Nj*ns
  double *rbfzt = &temp[4*n1 + n5 + 4*n2 + 3*n3]; // Nj*ns

  radialbasis(rbft, rbfxt, rbfyt, rbfzt, rij, besselparams, rin, rcut-rin, pdegree[0], pdegree[1], nbesselpars, Nj);

  char chn = 'N';
  double alpha = 1.0, beta = 0.0;
  DGEMM(&chn, &chn, &Nj, &nrbfmax, &ns, &alpha, rbft, &Nj, Phi, &ns, &beta, rbf, &Nj);
  DGEMM(&chn, &chn, &Nj, &nrbfmax, &ns, &alpha, rbfxt, &Nj, Phi, &ns, &beta, rbfx, &Nj);
  DGEMM(&chn, &chn, &Nj, &nrbfmax, &ns, &alpha, rbfyt, &Nj, Phi, &ns, &beta, rbfy, &Nj);
  DGEMM(&chn, &chn, &Nj, &nrbfmax, &ns, &alpha, rbfzt, &Nj, Phi, &ns, &beta, rbfz, &Nj);

  if ((nl2>0) && (Nj>0)) {
    twobodydesc(d2, rbf, tj, Nj);
  }

  if ((nl3 > 0) && (Nj>1)) {
    double *abf = &temp[4*n1 + n5 + 4*n2]; // Nj*K3
    double *abfx = &temp[4*n1 + n5 + 4*n2 + n4]; // Nj*K3
    double *abfy = &temp[4*n1 + n5 + 4*n2 + 2*n4]; // Nj*K3
    double *abfz = &temp[4*n1 + n5 + 4*n2 + 3*n4]; // Nj*K3
    double *tm = &temp[4*n1 + n5 + 4*n2 + 4*n4]; // 4*K3

    angularbasis(abf, abfx, abfy, abfz, rij, tm, pq3, Nj, K3);

    radialangularbasis(sumU, U, Ux, Uy, Uz, rbf, rbfx, rbfy, rbfz,
            abf, abfx, abfy, abfz, tj, Nj, K3, nrbf3, nelements);

    threebodydesc(d3, sumU);

    if ((nl23>0) && (Nj>2)) {
      fourbodydesc23(d23, d2, d3);
    }

    if ((nl33>0) && (Nj>3)) {
      crossdesc(d33, d3, d3, ind33l, ind33r, nl33);
    }

    if ((nl4 > 0) && (Nj>2)) {
      fourbodydesc(d4, sumU);

      if ((nl34>0) && (Nj>4)) {
        crossdesc(d34, d3, d4, ind34l, ind34r, nl34);
      }

      if ((nl44>0) && (Nj>5)) {
        crossdesc(d44, d4, d4, ind44l, ind44r, nl44);
      }
    }
  }

  double *cb = &bdd[0];
  if (nClusters > 1) {
    e += peratom_environment_descriptors(cb, bd, &temp[4*n1 + n5 + 4*n2], ti);
  }
  else {
    e += peratombase_coefficients(cb, bd, ti);
  }

  double *cb2 =  &cb[0]; // nl3
  double *cb3 =  &cb[nl2]; // nl3
  double *cb4 =  &cb[(nl2 + nl3)]; // nl4
  double *cb33 = &cb[(nl2 + nl3 + nl4)]; // nl33
  double *cb34 = &cb[(nl2 + nl3 + nl4 + nl33)]; // nl34
  double *cb44 = &cb[(nl2 + nl3 + nl4 + nl33 + nl34)]; // nl44

  if ((nl33>0) && (Nj>3)) {
    crossdesc_reduction(cb3, cb3, cb33, d3, d3, ind33l, ind33r, nl33);
  }
  if ((nl34>0) && (Nj>4)) {
    crossdesc_reduction(cb3, cb4, cb34, d3, d4, ind34l, ind34r, nl34);
  }
  if ((nl44>0) && (Nj>5)) {
    crossdesc_reduction(cb4, cb4, cb44, d4, d4, ind44l, ind44r, nl44);
  }

  if ((nl2 > 0) && (Nj>0)) twobody_forces(fij, cb2, rbfx, rbfy, rbfz, tj, Nj);

  // Initialize forcecoeff to zero
  double *forcecoeff = &cb[(nl2 + nl3 + nl4)]; // nl33
  std::fill(forcecoeff, forcecoeff + nelements * K3 * nrbf3, 0.0);
  if ((nl3 > 0) && (Nj>1)) threebody_forcecoeff(forcecoeff, cb3, sumU);
  if ((nl4 > 0) && (Nj>2)) fourbody_forcecoeff(forcecoeff, cb4, sumU);
  if ((nl3 > 0) && (Nj>1)) allbody_forces(fij, forcecoeff, Ux, Uy, Uz, tj, Nj);

  return e;
}

double EAPOD::peratomenergyforce(double *fij, double *rij, double *temp,
        int *ti, int *tj, int Nj)
{
  if (Nj==0) {
    return coeff[nCoeffPerElement*(ti[0]-1)];
  }

  int N = 3*Nj;
  for (int n=0; n<N; n++) fij[n] = 0.0;

  double *coeff1 = &coeff[nCoeffPerElement*(ti[0]-1)];
  double e = coeff1[0];

  // calculate base descriptors and their derivatives with respect to atom coordinates
  peratombase_descriptors(bd, bdd, rij, temp, tj, Nj);

  if (nClusters > 1) { // multi-environment descriptors
    // calculate multi-environment descriptors and their derivatives with respect to atom coordinates
    peratomenvironment_descriptors(pd, pdd, bd, bdd, temp, ti[0] - 1,  Nj);

    for (int j = 0; j<nClusters; j++)
      for (int m=0; m<Mdesc; m++)
        e += coeff1[1 + m + j*Mdesc]*bd[m]*pd[j];

    double *cb = &temp[0];
    double *cp = &temp[Mdesc];
    for (int m = 0; m<Mdesc; m++) cb[m] = 0.0;
    for (int j = 0; j<nClusters; j++) cp[j] = 0.0;
    for (int j = 0; j<nClusters; j++)
      for (int m = 0; m<Mdesc; m++)  {
        cb[m] += coeff1[1 + m + j*Mdesc]*pd[j];
        cp[j] += coeff1[1 + m + j*Mdesc]*bd[m];
      }
    char chn = 'N';
    double alpha = 1.0, beta = 0.0;
    int inc1 = 1;
    DGEMV(&chn, &N, &Mdesc, &alpha, bdd, &N, cb, &inc1, &beta, fij, &inc1);
    DGEMV(&chn, &N, &nClusters, &alpha, pdd, &N, cp, &inc1, &alpha, fij, &inc1);
  }
  else { // single-environment descriptors
    for (int m=0; m<Mdesc; m++)
      e += coeff1[1+m]*bd[m];

    char chn = 'N';
    double alpha = 1.0, beta = 0.0;
    int inc1 = 1;
    DGEMV(&chn, &N, &Mdesc, &alpha, bdd, &N, &coeff1[1], &inc1, &beta, fij, &inc1);
  }

  return e;
}

double EAPOD::energyforce(double *force, double *x, int *atomtype, int *alist,
          int *jlist, int *pairnumsum, int natom)
{
  double etot = 0.0;
  for (int i=0; i<3*natom; i++) force[i] = 0.0;

  for (int i=0; i<natom; i++) {
    int Nj = pairnumsum[i+1] - pairnumsum[i]; // # neighbors around atom i

    if (Nj==0) {
      etot += coeff[nCoeffPerElement*(atomtype[i]-1)];
    }
    else
    {
      // reallocate temporary memory
      if (Nj>Njmax) {
        Njmax = Nj;
        free_temp_memory();
        allocate_temp_memory(Njmax);
      }

      double *rij = &tmpmem[0];    // 3*Nj
      double *fij = &tmpmem[3*Nj]; // 3*Nj
      int *ai = &tmpint[0];        // Nj
      int *aj = &tmpint[Nj];       // Nj
      int *ti = &tmpint[2*Nj];     // Nj
      int *tj = &tmpint[3*Nj];     // Nj

      myneighbors(rij, x, ai, aj, ti, tj, jlist, pairnumsum, atomtype, alist, i);

      etot += peratomenergyforce(fij, rij, &tmpmem[6*Nj], ti, tj, Nj);

      tallyforce(force, fij, ai, aj, Nj);
    }
  }

  return etot;
}

void EAPOD::base_descriptors(double *basedesc, double *x,
        int *atomtype, int *alist, int *jlist, int *pairnumsum, int natom)
{
  for (int i=0; i<natom*Mdesc; i++) basedesc[i] = 0.0;

  for (int i=0; i<natom; i++) {
    int Nj = pairnumsum[i+1] - pairnumsum[i]; // # neighbors around atom i

    if (Nj>0) {
      // reallocate temporary memory
      if (Nj>Njmax) {
        Njmax = Nj;
        free_temp_memory();
        allocate_temp_memory(Njmax);
        if (comm->me == 0) utils::logmesg(lmp, "reallocate temporary memory with Njmax = %d ...\n", Njmax);
      }

      double *rij = &tmpmem[0]; // 3*Nj
      int *ai = &tmpint[0];     // Nj
      int *aj = &tmpint[Nj];   // Nj
      int *ti = &tmpint[2*Nj]; // Nj
      int *tj = &tmpint[3*Nj]; // Nj

      myneighbors(rij, x, ai, aj, ti, tj, jlist, pairnumsum, atomtype, alist, i);

      // many-body descriptors
      peratombase_descriptors(bd, bdd, rij, &tmpmem[3*Nj], tj, Nj);

      for (int m=0; m<Mdesc; m++) {
        basedesc[i + natom*(m)] = bd[m];
      }

    }
  }
}

void EAPOD::descriptors(double *gd, double *gdd, double *basedesc, double *x,
        int *atomtype, int *alist, int *jlist, int *pairnumsum, int natom)
{
  for (int i=0; i<nd; i++) gd[i] = 0.0;
  for (int i=0; i<3*natom*nd; i++) gdd[i] = 0.0;
  for (int i=0; i<natom*Mdesc; i++) basedesc[i] = 0.0;

  for (int i=0; i<natom; i++) {
    int Nj = pairnumsum[i+1] - pairnumsum[i]; // # neighbors around atom i

    // one-body descriptor
    if (nd1>0) {
      gd[nCoeffPerElement*(atomtype[i]-1)] += 1.0;
    }

    if (Nj>0) {
      // reallocate temporary memory
      if (Nj>Njmax) {
        Njmax = Nj;
        free_temp_memory();
        allocate_temp_memory(Njmax);
        if (comm->me == 0) utils::logmesg(lmp, "reallocate temporary memory with Njmax = %d ...\n", Njmax);
      }

      double *rij = &tmpmem[0]; // 3*Nj
      int *ai = &tmpint[0];     // Nj
      int *aj = &tmpint[Nj];   // Nj
      int *ti = &tmpint[2*Nj]; // Nj
      int *tj = &tmpint[3*Nj]; // Nj

      myneighbors(rij, x, ai, aj, ti, tj, jlist, pairnumsum, atomtype, alist, i);

      // many-body descriptors
      peratombase_descriptors(bd, bdd, rij, &tmpmem[3*Nj], tj, Nj);

      for (int m=0; m<Mdesc; m++) {
        basedesc[i + natom*(m)] = bd[m];
        int k = nCoeffPerElement*(ti[0]-1) + nl1 + m; // increment by nl1 because of the one-body descriptor
        gd[k] += bd[m];
        for (int n=0; n<Nj; n++) {
          int im = 3*ai[n] + 3*natom*k;
          int jm = 3*aj[n] + 3*natom*k;
          int nm = 3*n + 3*Nj*m;
          gdd[0 + im] += bdd[0 + nm];
          gdd[1 + im] += bdd[1 + nm];
          gdd[2 + im] += bdd[2 + nm];
          gdd[0 + jm] -= bdd[0 + nm];
          gdd[1 + jm] -= bdd[1 + nm];
          gdd[2 + jm] -= bdd[2 + nm];
        }
      }

    }
  }
}

void EAPOD::descriptors(double *gd, double *gdd, double *basedesc, double *probdesc, double *x,
        int *atomtype, int *alist, int *jlist, int *pairnumsum, int natom)
{
  for (int i=0; i<nCoeffAll; i++) gd[i] = 0.0;
  for (int i=0; i<3*natom*nCoeffAll; i++) gdd[i] = 0.0;
  for (int i=0; i<natom*Mdesc; i++) basedesc[i] = 0.0;
  for (int i=0; i<natom*nClusters; i++) probdesc[i] = 0.0;

  for (int i=0; i<natom; i++) {
    int Nj = pairnumsum[i+1] - pairnumsum[i]; // # neighbors around atom i

    // one-body descriptor
    if (nd1>0) {
      gd[nCoeffPerElement*(atomtype[i]-1)] += 1.0;
    }

    if (Nj>0) {
      // reallocate temporary memory
      if (Nj>Njmax) {
        Njmax = Nj;
        free_temp_memory();
        allocate_temp_memory(Njmax);
        if (comm->me == 0) utils::logmesg(lmp, "reallocate temporary memory with Njmax = %d ...\n", Njmax);
      }

      double *rij = &tmpmem[0]; // 3*Nj
      int *ai = &tmpint[0];     // Nj
      int *aj = &tmpint[Nj];   // Nj
      int *ti = &tmpint[2*Nj]; // Nj
      int *tj = &tmpint[3*Nj]; // Nj

      myneighbors(rij, x, ai, aj, ti, tj, jlist, pairnumsum, atomtype, alist, i);

      // many-body descriptors
      peratombase_descriptors(bd, bdd, rij, &tmpmem[3*Nj], tj, Nj);

      // calculate multi-environment descriptors and their derivatives with respect to atom coordinates
      peratomenvironment_descriptors(pd, pdd, bd, bdd, tmpmem, ti[0] - 1,  Nj);

      for (int j = 0; j < nClusters; j++) {
        probdesc[i + natom*(j)] = pd[j];
        for (int m=0; m<Mdesc; m++) {
          basedesc[i + natom*(m)] = bd[m];
          int k = nCoeffPerElement*(ti[0]-1) + nl1 + m + j*Mdesc; // increment by nl1 because of the one-body descriptor
          gd[k] += pd[j]*bd[m];
          for (int n=0; n<Nj; n++) {
            int im = 3*ai[n] + 3*natom*k;
            int jm = 3*aj[n] + 3*natom*k;
            int nm = 3*n + 3*Nj*m;
            int nj = 3*n + 3*Nj*j;
            gdd[0 + im] += bdd[0 + nm]*pd[j] + bd[m]*pdd[0 + nj];
            gdd[1 + im] += bdd[1 + nm]*pd[j] + bd[m]*pdd[1 + nj];
            gdd[2 + im] += bdd[2 + nm]*pd[j] + bd[m]*pdd[2 + nj];
            gdd[0 + jm] -= bdd[0 + nm]*pd[j] + bd[m]*pdd[0 + nj];
            gdd[1 + jm] -= bdd[1 + nm]*pd[j] + bd[m]*pdd[1 + nj];
            gdd[2 + jm] -= bdd[2 + nm]*pd[j] + bd[m]*pdd[2 + nj];
          }
        }
      }

    }
  }
}

void EAPOD::fourbodydesc23(double *d23, double *d2, double *d3)
{
  for (int j = 0; j<n32; j++)
    for (int i = 0; i<n23; i++)
      d23[i + n23*j] = d2[ind23[i]]*d3[ind32[j]];
}

void EAPOD::fourbodydescderiv23(double* dd23, double *d2, double *d3, double *dd2, double *dd3, int N)
{
  for (int j = 0; j<n32; j++)
    for (int i = 0; i<n23; i++)
      for (int n=0; n<N; n++)
        dd23[n + N*i + N*n23*j] = d2[ind23[i]]*dd3[n + N*ind32[j]] + dd2[n + N*ind23[i]]*d3[ind32[j]];
}

void EAPOD::crossdesc(double *d12, double *d1, double *d2, int *ind1, int *ind2, int n12)
{
  for (int i = 0; i<n12; i++)
    d12[i] = d1[ind1[i]]*d2[ind2[i]];
}

void EAPOD::crossdescderiv(double *dd12, double *d1, double *d2, double *dd1, double *dd2,
        int *ind1, int *ind2, int n12, int N)
{
  for (int i = 0; i<n12; i++)
    for (int n=0; n<N; n++)
      dd12[n + N*i] = d1[ind1[i]]*dd2[n + N*ind2[i]] + dd1[n + N*ind1[i]]*d2[ind2[i]];
}

void EAPOD::crossdesc_reduction(double *cb1, double *cb2, double *c12, double *d1,
        double *d2, int *ind1, int *ind2, int n12)
{
  for (int m = 0; m < n12; m++) {
    int k1 = ind1[m]; // dd1
    int k2 = ind2[m]; // dd2
    double c = c12[m];
    cb1[k1] += c * d2[k2];
    cb2[k2] += c * d1[k1];
  }
}

void EAPOD::myneighbors(double *rij, double *x, int *ai, int *aj, int *ti, int *tj,
        int *jlist, int *pairnumsum, int *atomtype, int *alist, int i)
{
  int itype = atomtype[i];
  int start = pairnumsum[i];
  int m = pairnumsum[i+1] - start; // number of neighbors around i
  for (int l=0; l<m ; l++) {   // loop over each atom around atom i
    int j = jlist[l + start];  // atom j
    ai[l]        = i;
    aj[l]        = alist[j];
    ti[l]        = itype;
    tj[l]        = atomtype[alist[j]];
    rij[0 + 3*l]   = x[0 + 3*j] -  x[0 + 3*i];
    rij[1 + 3*l]   = x[1 + 3*j] -  x[1 + 3*i];
    rij[2 + 3*l]   = x[2 + 3*j] -  x[2 + 3*i];
  }
}

void EAPOD::fourbodydesc(double *d4, double *sumU)
{
  int Me = nelements*(nelements+1)*(nelements+2)/6; //count4(nelements);
  for (int m=0; m<nabf4*nrbf4*Me; m++)
    d4[m] = 0.0;

  for (int m = 0; m < nrbf4; m++) {
    int idxU = nelements * K3 * m;
    for (int p = 0; p < nabf4; p++) {
      int n1 = pa4[p];
      int n2 = pa4[p + 1];
      int nn = n2 - n1;
      for (int q = 0; q < nn; q++) {
        int c = pc4[n1 + q];
        int j1 = pb4[n1 + q];
        int j2 = pb4[n1 + q + Q4];
        int j3 = pb4[n1 + q + 2 * Q4];
        int k = 0;
        for (int i1 = 0; i1 < nelements; i1++) {
          double c1 =  sumU[idxU + i1 + nelements * j1];
          for (int i2 = i1; i2 < nelements; i2++) {
            double c2 = sumU[idxU + i2 + nelements * j2];
            double t12 = c * c1 * c2;
            for (int i3 = i2; i3 < nelements; i3++) {
              double c3 = sumU[idxU + i3 + nelements * j3];
              int kk = p + nabf4 * m + nabf4 * nrbf4 * k;
              d4[kk] += t12 * c3;
              k += 1;
            }
          }
        }
      }
    }
  }
}

void EAPOD::fourbodydescderiv(double *d4, double *dd4, double *sumU, double *Ux, double *Uy,
        double *Uz, int *atomtype, int N)
{
  int Me = nelements*(nelements+1)*(nelements+2)/6; //count4(nelements);
  for (int m=0; m<nabf4*nrbf4*Me; m++)
    d4[m] = 0.0;

  for (int m=0; m<3*N*nabf4*nrbf4*Me; m++)
    dd4[m] = 0.0;

  int Q = pa4[nabf4];

  if (nelements==1) {
    for (int m=0; m<nrbf4; m++)
      for (int p=0; p<nabf4; p++) {
        int n1 = pa4[p];
        int n2 = pa4[p+1];
        int nn = n2 - n1;
        for (int q=0; q<nn; q++) {
          int c = pc4[n1+q];
          int j1 = pb4[n1+q];
          int j2 = pb4[n1+q + Q];
          int j3 = pb4[n1+q + 2*Q];
          double c1 = c*sumU[j1 + K4*m];
          double c2 = c*sumU[j2 + K4*m];
          double t12 = c1*sumU[j2 + K4*m];
          double c3 = sumU[j3 + K4*m];
          double t13 = c1*c3;
          double t23 = c2*c3;
          int kk = p + nabf4*m;
          int ii = 3*N*(p + nabf4*m);
          d4[kk] += t12*c3;
          for (int j=0; j<N; j++) {
            int jj = j + N*j3 + N*K4*m;
            dd4[0 + 3*j + ii] += t12*Ux[jj];
            dd4[1 + 3*j + ii] += t12*Uy[jj];
            dd4[2 + 3*j + ii] += t12*Uz[jj];
            jj = j + N*j2 + N*K4*m;
            dd4[0 + 3*j + ii] += t13*Ux[jj];
            dd4[1 + 3*j + ii] += t13*Uy[jj];
            dd4[2 + 3*j + ii] += t13*Uz[jj];
            jj = j + N*j1 + N*K4*m;
            dd4[0 + 3*j + ii] += t23*Ux[jj];
            dd4[1 + 3*j + ii] += t23*Uy[jj];
            dd4[2 + 3*j + ii] += t23*Uz[jj];
          }
        }
      }
  }
  else {
    for (int m=0; m<nrbf4; m++)
      for (int p=0; p<nabf4; p++) {
        int n1 = pa4[p];
        int n2 = pa4[p+1];
        int nn = n2 - n1;
        for (int q=0; q<nn; q++) {
          int c = pc4[n1+q];
          int j1 = pb4[n1+q];
          int j2 = pb4[n1+q + Q];
          int j3 = pb4[n1+q + 2*Q];
          int k = 0;
          for (int i1=0; i1<nelements; i1++) {
            double c1 = c*sumU[i1 + nelements*j1 + nelements*K4*m];
            for (int i2=i1; i2<nelements; i2++) {
              double c2 = c*sumU[i2 + nelements*j2 + nelements*K4*m];
              double t12 = c1*sumU[i2 + nelements*j2 + nelements*K4*m];
              for (int i3=i2; i3<nelements; i3++) {
                double c3 = sumU[i3 + nelements*j3 + nelements*K4*m];
                double t13 = c1*c3;
                double t23 = c2*c3;
                int kk = p + nabf4*m + nabf4*nrbf4*k;
                int ii = 3*N*(p + nabf4*m + nabf4*nrbf4*k);
                d4[kk] += t12*c3;
                for (int j=0; j<N; j++) {
                  int tj = atomtype[j]-1;
                  if (tj==i3) {
                    int jj = j + N*j3 + N*K4*m;
                    dd4[0 + 3*j + ii] += t12*Ux[jj];
                    dd4[1 + 3*j + ii] += t12*Uy[jj];
                    dd4[2 + 3*j + ii] += t12*Uz[jj];
                  }
                  if (tj==i2) {
                    int jj = j + N*j2 + N*K4*m;
                    dd4[0 + 3*j + ii] += t13*Ux[jj];
                    dd4[1 + 3*j + ii] += t13*Uy[jj];
                    dd4[2 + 3*j + ii] += t13*Uz[jj];
                  }
                  if (tj==i1) {
                    int jj = j + N*j1 + N*K4*m;
                    dd4[0 + 3*j + ii] += t23*Ux[jj];
                    dd4[1 + 3*j + ii] += t23*Uy[jj];
                    dd4[2 + 3*j + ii] += t23*Uz[jj];
                  }
                }
                k += 1;
              }
            }
          }
        }
      }
  }
}

void EAPOD::threebodydesc(double *d3, double *sumU)
{
  int Me = nelements*(nelements+1)/2;
  for (int m=0; m<nabf3*nrbf3*Me; m++)
    d3[m] = 0.0;

  if (nelements==1) {
    for (int m=0; m<nrbf3; m++)
      for (int p=0; p<nabf3; p++) {
        int n1 = pn3[p];
        int n2 = pn3[p+1];
        int nn = n2 - n1;
        for (int q=0; q<nn; q++) {
          double t1 = pc3[n1+q]*sumU[(n1+q) + K3*m];
          d3[p + nabf3*m] += t1*sumU[(n1+q) + K3*m];
        }
      }
  }
  else {
    for (int m=0; m<nrbf3; m++)
      for (int p=0; p<nabf3; p++) {
        int n1 = pn3[p];
        int n2 = pn3[p+1];
        int nn = n2 - n1;
        for (int q=0; q<nn; q++) {
          int k = 0;
          for (int i1=0; i1<nelements; i1++) {
            double t1 = pc3[n1+q]*sumU[i1 + nelements*(n1+q) + nelements*K3*m];
            for (int i2=i1; i2<nelements; i2++) {
              d3[p + nabf3*m + nabf3*nrbf3*k] += t1*sumU[i2 + nelements*(n1+q) + nelements*K3*m];
              k += 1;
            }
          }
        }
      }
  }
}

void EAPOD::threebodydescderiv(double *dd3, double *sumU, double *Ux, double *Uy, double *Uz,
        int *atomtype, int N)
{
  int Me = nelements*(nelements+1)/2;
  for (int m=0; m<3*N*nabf3*nrbf3*Me; m++)
    dd3[m] = 0.0;

  if (nelements==1) {
    for (int m=0; m<nrbf3; m++)
      for (int p=0; p<nabf3; p++) {
        int n1 = pn3[p];
        int n2 = pn3[p+1];
        int nn = n2 - n1;
        for (int q=0; q<nn; q++) {
          double t1 = pc3[n1+q]*sumU[(n1+q) + K3*m];
          for (int j=0; j<N; j++) {
            double f = 2.0*t1;
            int ii = 3*j + 3*N*(p + nabf3*m);
            int jj = j + N*(n1+q) + N*K3*m;
            dd3[0 + ii] += f*Ux[jj];
            dd3[1 + ii] += f*Uy[jj];
            dd3[2 + ii] += f*Uz[jj];
          }
        }
      }
  }
  else {
    for (int m=0; m<nrbf3; m++)
      for (int p=0; p<nabf3; p++) {
        int n1 = pn3[p];
        int n2 = pn3[p+1];
        int nn = n2 - n1;
        for (int q=0; q<nn; q++) {
          for (int i1=0; i1<nelements; i1++) {
            double t1 = pc3[n1+q]*sumU[i1 + nelements*(n1+q) + nelements*K3*m];
            for (int j=0; j<N; j++) {
              int i2 = atomtype[j]-1;
              int k = elemindex[i2 + nelements*i1];
              double f = (i1==i2) ? 2.0*t1 : t1;
              int ii = 3*j + 3*N*(p + nabf3*m + nabf3*nrbf3*k);
              int jj = j + N*(n1+q) + N*K3*m;
              dd3[0 + ii] += f*Ux[jj];
              dd3[1 + ii] += f*Uy[jj];
              dd3[2 + ii] += f*Uz[jj];
            }
          }
        }
      }
  }
}

void EAPOD::twobodydesc(double *d2, double *rbf, int *tj, int N)
{
  // Initialize the two-body descriptors and their derivatives to zero
  for (int m=0; m<nl2; m++)
    d2[m] = 0.0;

  // Calculate the two-body descriptors and their derivatives
  for (int m=0; m<nrbf2; m++) {
    for (int n=0; n<N; n++) {
      int i2 = n + N*m; // Index of the radial basis function for atom n and RBF m
      d2[m + nrbf2*(tj[n]-1)] += rbf[i2]; // Add the radial basis function to the corresponding descriptor
    }
  }
}

/**
 * @brief Calculates the two-body descriptor derivatives for a given set of atoms.
 *
 * @param d2   Pointer to the array of two-body descriptors.
 * @param dd2  Pointer to the array of two-body descriptor derivatives.
 * @param rbf  Pointer to the array of radial basis functions.
 * @param rbfx Pointer to the array of radial basis function derivatives with respect to x.
 * @param rbfy Pointer to the array of radial basis function derivatives with respect to y.
 * @param rbfz Pointer to the array of radial basis function derivatives with respect to z.
 * @param tj   Pointer to the array of atom types of neighboring atoms.
 * @param N    Number of neighboring atoms.
 */
void EAPOD::twobodydescderiv(double *d2, double *dd2, double *rbf, double *rbfx,
        double *rbfy, double *rbfz, int *tj, int N)
{
  // Initialize the two-body descriptors and their derivatives to zero
  for (int m=0; m<nl2; m++)
    d2[m] = 0.0;
  for (int m=0; m<3*N*nl2; m++)
    dd2[m] = 0.0;

  // Calculate the two-body descriptors and their derivatives
  for (int m=0; m<nrbf2; m++) {
    for (int n=0; n<N; n++) {
      int i2 = n + N*m; // Index of the radial basis function for atom n and RBF m
      int i1 = n + N*m + N*nrbf2*(tj[n]-1); // Index of the descriptor for atom n, RBF m, and atom type tj[n]
      d2[m + nrbf2*(tj[n]-1)] += rbf[i2]; // Add the radial basis function to the corresponding descriptor
      dd2[0 + 3*i1] += rbfx[i2]; // Add the derivative with respect to x to the corresponding descriptor derivative
      dd2[1 + 3*i1] += rbfy[i2]; // Add the derivative with respect to y to the corresponding descriptor derivative
      dd2[2 + 3*i1] += rbfz[i2]; // Add the derivative with respect to z to the corresponding descriptor derivative
    }
  }
}

/**
 * @brief Calculates the radial basis functions and their derivatives.
 *
 * @param rbf           Pointer to the array of radial basis functions.
 * @param rbfx          Pointer to the array of derivatives of radial basis functions with respect to x.
 * @param rbfy          Pointer to the array of derivatives of radial basis functions with respect to y.
 * @param rbfz          Pointer to the array of derivatives of radial basis functions with respect to z.
 * @param rij           Pointer to the relative positions of neighboring atoms and atom i.
 * @param besselparams  Pointer to the array of Bessel function parameters.
 * @param rin           Minimum distance for radial basis functions.
 * @param rmax          Maximum distance for radial basis functions.
 * @param besseldegree  Degree of Bessel functions.
 * @param inversedegree Degree of inverse distance functions.
 * @param nbesselpars   Number of Bessel function parameters.
 * @param N             Number of neighboring atoms.
 */
void EAPOD::radialbasis(double *rbf, double *rbfx, double *rbfy, double *rbfz, double *rij, double *besselparams, double rin,
        double rmax, int besseldegree, int inversedegree, int nbesselpars, int N)
{
  // Loop over all neighboring atoms
  for (int n=0; n<N; n++) {
    double xij1 = rij[0+3*n];
    double xij2 = rij[1+3*n];
    double xij3 = rij[2+3*n];

    double dij = sqrt(xij1*xij1 + xij2*xij2 + xij3*xij3);
    double dr1 = xij1/dij;
    double dr2 = xij2/dij;
    double dr3 = xij3/dij;

    double r = dij - rin;
    double y = r/rmax;
    double y2 = y*y;

    double y3 = 1.0 - y2*y;
    double y4 = y3*y3 + 1e-6;
    double y5 = sqrt(y4);
    double y6 = exp(-1.0/y5);
    double y7 = y4*sqrt(y4);

    // Calculate the final cutoff function as y6/exp(-1)
    double fcut = y6/exp(-1.0);

    // Calculate the derivative of the final cutoff function
    double dfcut = ((3.0/(rmax*exp(-1.0)))*(y2)*y6*(y*y2 - 1.0))/y7;

    // Calculate fcut/r, fcut/r^2, and dfcut/r
    double f1 = fcut/r;
    double f2 = f1/r;
    double df1 = dfcut/r;

    double alpha = besselparams[0];
    double t1 = (1.0-exp(-alpha));
    double t2 = exp(-alpha*r/rmax);
    double x0 =  (1.0 - t2)/t1;
    double dx0 = (alpha/rmax)*t2/t1;

    if (nbesselpars==1) {
      for (int i=0; i<besseldegree; i++) {
        double a = (i+1)*MY_PI;
        double b = (sqrt(2.0/(rmax))/(i+1));
        double af1 = a*f1;

        double sinax = sin(a*x0);
        int nij = n + N*i;

        rbf[nij] = b*f1*sinax;

        double drbfdr = b*(df1*sinax - f2*sinax + af1*cos(a*x0)*dx0);
        rbfx[nij] = drbfdr*dr1;
        rbfy[nij] = drbfdr*dr2;
        rbfz[nij] = drbfdr*dr3;
      }
    }
    else if (nbesselpars==2) {
      alpha = besselparams[1];
      t1 = (1.0-exp(-alpha));
      t2 = exp(-alpha*r/rmax);
      double x1 =  (1.0 - t2)/t1;
      double dx1 = (alpha/rmax)*t2/t1;
      for (int i=0; i<besseldegree; i++) {
        double a = (i+1)*MY_PI;
        double b = (sqrt(2.0/(rmax))/(i+1));
        double af1 = a*f1;

        double sinax = sin(a*x0);
        int nij = n + N*i;

        rbf[nij] = b*f1*sinax;

        double drbfdr = b*(df1*sinax - f2*sinax + af1*cos(a*x0)*dx0);
        rbfx[nij] = drbfdr*dr1;
        rbfy[nij] = drbfdr*dr2;
        rbfz[nij] = drbfdr*dr3;

        sinax = sin(a*x1);
        nij = n + N*i + N*besseldegree*1;
        rbf[nij] = b*f1*sinax;

        drbfdr = b*(df1*sinax - f2*sinax + af1*cos(a*x1)*dx1);
        rbfx[nij] = drbfdr*dr1;
        rbfy[nij] = drbfdr*dr2;
        rbfz[nij] = drbfdr*dr3;
      }
    }
    else if (nbesselpars==3) {
      alpha = besselparams[1];
      t1 = (1.0-exp(-alpha));
      t2 = exp(-alpha*r/rmax);
      double x1 =  (1.0 - t2)/t1;
      double dx1 = (alpha/rmax)*t2/t1;

      alpha = besselparams[2];
      t1 = (1.0-exp(-alpha));
      t2 = exp(-alpha*r/rmax);
      double x2 =  (1.0 - t2)/t1;
      double dx2 = (alpha/rmax)*t2/t1;
      for (int i=0; i<besseldegree; i++) {
        double a = (i+1)*MY_PI;
        double b = (sqrt(2.0/(rmax))/(i+1));
        double af1 = a*f1;

        double sinax = sin(a*x0);
        int nij = n + N*i;

        rbf[nij] = b*f1*sinax;
        double drbfdr = b*(df1*sinax - f2*sinax + af1*cos(a*x0)*dx0);
        rbfx[nij] = drbfdr*dr1;
        rbfy[nij] = drbfdr*dr2;
        rbfz[nij] = drbfdr*dr3;

        sinax = sin(a*x1);
        nij = n + N*i + N*besseldegree*1;

        rbf[nij] = b*f1*sinax;
        drbfdr = b*(df1*sinax - f2*sinax + af1*cos(a*x1)*dx1);
        rbfx[nij] = drbfdr*dr1;
        rbfy[nij] = drbfdr*dr2;
        rbfz[nij] = drbfdr*dr3;

        sinax = sin(a*x2);
        nij = n + N*i + N*besseldegree*2;
        rbf[nij] = b*f1*sinax;
        drbfdr = b*(df1*sinax - f2*sinax + af1*cos(a*x2)*dx2);
        rbfx[nij] = drbfdr*dr1;
        rbfy[nij] = drbfdr*dr2;
        rbfz[nij] = drbfdr*dr3;
      }
    }

    // Calculate fcut/dij and dfcut/dij
    f1 = fcut/dij;
    for (int i=0; i<inversedegree; i++) {
      int p = besseldegree*nbesselpars + i;
      int nij = n + N*p;
      double a = powint(dij, i+1);

      rbf[nij] = fcut/a;

      double drbfdr = (dfcut - (i+1.0)*f1)/a;
      rbfx[nij] = drbfdr*dr1;
      rbfy[nij] = drbfdr*dr2;
      rbfz[nij] = drbfdr*dr3;
    }
  }
}

/**
 * @brief Calculates the angular basis functions and their derivatives.
 *
 * @param abf   Pointer to the angular basis functions.
 * @param abfx  Pointer to the derivative of the angular basis functions w.r.t. x.
 * @param abfy  Pointer to the derivative of the angular basis functions w.r.t. y.
 * @param abfz  Pointer to the derivative of the angular basis functions w.r.t. z.
 * @param rij   Pointer to the relative positions of neighboring atoms and atom i.
 * @param tm    Pointer to temporary array.
 * @param pq    Pointer to array of indices for angular basis functions.
 * @param N     Number of neighboring atoms.
 * @param K     Number of angular basis functions.
 */
void EAPOD::angularbasis(double *abf, double *abfx, double *abfy, double *abfz, double *rij, double *tm, int *pq, int N, int K)
{
  // Initialize temporary arrays
  double *tmu = &tm[K];
  double *tmv = &tm[2*K];
  double *tmw = &tm[3*K];

  // Initialize first angular basis function and its derivatives
  tm[0] = 1.0;
  tmu[0] = 0.0;
  tmv[0] = 0.0;
  tmw[0] = 0.0;

  // Loop over all neighboring atoms
  for (int j=0; j<N; j++) {
    // Calculate relative positions of neighboring atoms and atom i
    double x = rij[0+3*j];
    double y = rij[1+3*j];
    double z = rij[2+3*j];

    // Calculate various terms for derivatives
    double xx = x*x;
    double yy = y*y;
    double zz = z*z;
    double xy = x*y;
    double xz = x*z;
    double yz = y*z;

    // Calculate distance between neighboring atoms and unit vectors
    double dij = sqrt(xx + yy + zz);
    double u = x/dij;
    double v = y/dij;
    double w = z/dij;

    // Calculate derivatives of unit vectors
    double dij3 = dij*dij*dij;
    double dudx = (yy+zz)/dij3;
    double dudy = -xy/dij3;
    double dudz = -xz/dij3;

    double dvdx = -xy/dij3;
    double dvdy = (xx+zz)/dij3;
    double dvdz = -yz/dij3;

    double dwdx = -xz/dij3;
    double dwdy = -yz/dij3;
    double dwdz = (xx+yy)/dij3;

    // Initialize first angular basis function and its derivatives
    abf[j] = tm[0];
    abfx[j] = 0.0;
    abfy[j] = 0.0;
    abfz[j] = 0.0;

    // Loop over all angular basis functions
    for (int n=1; n<K; n++) {
      // Get indices for angular basis function
      int m = pq[n]-1;
      int d = pq[n + K];

      // Calculate angular basis function and its derivatives using recursion relation
      if (d==1) {
        tm[n] = tm[m]*u;
        tmu[n] = tmu[m]*u + tm[m];
        tmv[n] = tmv[m]*u;
        tmw[n] = tmw[m]*u;
      }
      else if (d==2) {
        tm[n] = tm[m]*v;
        tmu[n] = tmu[m]*v;
        tmv[n] = tmv[m]*v + tm[m];
        tmw[n] = tmw[m]*v;
      }
      else if (d==3) {
        tm[n] = tm[m]*w;
        tmu[n] = tmu[m]*w;
        tmv[n] = tmv[m]*w;
        tmw[n] = tmw[m]*w + tm[m];
      }
      abf[j + N*n] = tm[n];
      abfx[j + N*n] = tmu[n]*dudx + tmv[n]*dvdx + tmw[n]*dwdx;
      abfy[j + N*n] = tmu[n]*dudy + tmv[n]*dvdy + tmw[n]*dwdy;
      abfz[j + N*n] = tmu[n]*dudz + tmv[n]*dvdz + tmw[n]*dwdz;
    }
  }
}

/**
 * @brief Calculates the radial-angular basis functions and their derivatives.
 *
 * @param sumU  Pointer to the array to store the sum of the basis functions.
 * @param U     Pointer to the array to store the radial-angular basis functions.
 * @param Ux    Pointer to the array to store the derivative of U with respect to x.
 * @param Uy    Pointer to the array to store the derivative of U with respect to y.
 * @param Uz    Pointer to the array to store the derivative of U with respect to z.
 * @param rbf   Pointer to the radial basis function array.
 * @param rbfx  Pointer to the derivative of rbf with respect to x.
 * @param rbfy  Pointer to the derivative of rbf with respect to y.
 * @param rbfz  Pointer to the derivative of rbf with respect to z.
 * @param abf   Pointer to the angular basis function array.
 * @param abfx  Pointer to the derivative of abf with respect to x.
 * @param abfy  Pointer to the derivative of abf with respect to y.
 * @param abfz  Pointer to the derivative of abf with respect to z.
 * @param tm    Pointer to the temporary memory array .
 * @param atomtype  Pointer to the array of atom types.
 * @param N     Number of neighboring atoms.
 * @param K     Number of angular basis functions.
 * @param M     Number of radial basis functions.
 * @param Ne    Number of elements.
 */
void EAPOD::radialangularbasis(double *sumU, double *U, double *Ux, double *Uy, double *Uz,
                 double *rbf, double *rbfx, double *rbfy, double *rbfz,
                 double *abf, double *abfx, double *abfy, double *abfz,
                 int *atomtype, int N, int K, int M, int Ne)
{
  // Initialize sumU to zero
  std::fill(sumU, sumU + Ne * K * M, 0.0);

  // Calculate radial-angular basis functions
  if (Ne == 1) { // Case when Ne is 1
    // Case when Ne is not 1
    for (int m = 0; m < M; m++) {
      for (int k = 0; k < K; k++) {
        double sum = 0.0;
        for (int n = 0; n < N; n++) {
          int ia = n + N * k;
          int ib = n + N * m;
          int ii = ia + N * K * m;

          // Calculate c1 and c2
          double c1 = rbf[ib];
          double c2 = abf[ia];

          // Calculate U, Ux, Uy, Uz
          U[ii] = c1 * c2;
          Ux[ii] = abfx[ia] * c1 + c2 * rbfx[ib];
          Uy[ii] = abfy[ia] * c1 + c2 * rbfy[ib];
          Uz[ii] = abfz[ia] * c1 + c2 * rbfz[ib];

          // Update sum
          sum += c1 * c2;
        }
        // Update sumU
        sumU[k + K * m] += sum;
      }
    }
  } else { // Case when Ne is not 1
    // Loop over all radial, angular basis functions, and neighboring atoms
    for (int m = 0; m < M; m++) {
      for (int k = 0; k < K; k++) {
        for (int n = 0; n < N; n++) {
          int ia = n + N * k;
          int ib = n + N * m;
          int ii = ia + N * K * m;

          // Calculate c1 and c2
          double c1 = rbf[ib];
          double c2 = abf[ia];

          // Calculate U, Ux, Uy, Uz
          U[ii] = c1 * c2;
          Ux[ii] = abfx[ia] * c1 + c2 * rbfx[ib];
          Uy[ii] = abfy[ia] * c1 + c2 * rbfy[ib];
          Uz[ii] = abfz[ia] * c1 + c2 * rbfz[ib];

          // Update sumU with atomtype adjustment
          int tn = atomtype[n] - 1; // offset the atom type by 1, since atomtype is 1-based
          sumU[tn + Ne * k + Ne * K * m] += c1 * c2;
        }
      }
    }
  }
}

/**
 * @brief Tally the force on each atom i and its neighboring atoms.
 *
 * @param force Pointer to the output array for the global force
 * @param fij Pointer to the array of forces between each pair of neighboring atoms.
 * @param ai Pointer to the array of atom indices for each pair of neighboring atoms.
 * @param aj Pointer to the array of neighboring atom indices for each pair of neighboring atoms.
 * @param N Number of neighboring atom pairs.
 */
void EAPOD::tallyforce(double *force, double *fij,  int *ai, int *aj, int N)
{
  // Loop over all neighboring atoms
  for (int n=0; n<N; n++) {
    int im =  3*ai[n]; // Output index for the force on atom i
    int jm =  3*aj[n]; // Output index for the force on atom j
    int nm = 3*n; // Input index for the force between atom i and j
    force[0 + im] += fij[0 + nm]; // Tally the x-component of the force on atom i
    force[1 + im] += fij[1 + nm]; // Tally the y-component of the force on atom i
    force[2 + im] += fij[2 + nm]; // Tally the z-component of the force on atom i
    force[0 + jm] -= fij[0 + nm]; // Tally the x-component of the force on atom j
    force[1 + jm] -= fij[1 + nm]; // Tally the y-component of the force on atom j
    force[2 + jm] -= fij[2 + nm]; // Tally the z-component of the force on atom j
  }
}

/**
 * @brief Create new coefficients for the local descriptors.
 *
 * @param c Pointer to the input array of original coefficients for the global descriptors.
 */
void EAPOD::mknewcoeff(double *c, int nc)
{
  // Allocate memory for the new coefficients
  memory->create(coeff, nc, "coeff");

  // Copy the  coefficients
  for (int n=0; n<nc; n++)
    coeff[n] = c[n];
}

/**
 * @brief Compute the radial basis function (RBF) for each atom.
 *
 * @param rbf Pointer to the output array for the RBF.
 * @param xij Pointer to the array of distances between each pair of atoms.
 * @param N Number of points in the interval [rin, rcut].
 */
void EAPOD::snapshots(double *rbf, double *xij, int N)
{
  // Compute the maximum distance between two atoms
  double rmax = rcut-rin;

  // Loop over all atoms
  for (int n=0; n<N; n++) {
    double dij = xij[n];

    // Compute the distance between two atoms
    double r = dij - rin;

    // Compute the normalized distance
    double y = r/rmax;
    double y2 = y*y;
    double y3 = 1.0 - y2*y;
    double y4 = y3*y3 + 1e-6;
    double y5 = sqrt(y4);
    double y6 = exp(-1.0/y5);

    // Compute the cutoff function
    double fcut = y6/exp(-1.0);

    // Loop over all Bessel parameters
    for (int j=0; j<nbesselpars; j++) {
      double alpha = besselparams[j];
      if (fabs(alpha) <= 1.0e-6) alpha = 1e-3;
      double x =  (1.0 - exp(-alpha*r/rmax))/(1.0-exp(-alpha));

      // Loop over all Bessel degrees
      for (int i=0; i<besseldegree; i++) {
        double a = (i+1)*MY_PI;
        double b = (sqrt(2.0/(rmax))/(i+1));
        int nij = n + N*i + N*besseldegree*j;

        // Compute the RBF
        rbf[nij] = b*fcut*sin(a*x)/r;
      }
    }

    // Loop over all polynomial degrees of the radial inverse functions
    for (int i=0; i<inversedegree; i++) {
      int p = besseldegree*nbesselpars + i;
      int nij = n + N*p;
      //double a = pow(dij, (double) (i+1.0));
      double a = powint(dij, i+1);

      // Compute the RBF
      rbf[nij] = fcut/a;
    }
  }
}


/**
 * @brief Perform eigenvalue decomposition of the snapshots matrix S and return the eigenvectors and eigenvalues.
 *
 * @param Phi Pointer to the output array for the eigenvectors.
 * @param Lambda Pointer to the output array for the eigenvalues.
 * @param N Number of points in the interval [rin, rcut].
 */
void EAPOD::eigenvaluedecomposition(double *Phi, double *Lambda, int N)
{
  int ns = besseldegree*nbesselpars + inversedegree;

  double *xij;
  double *S;
  double *Q;
  double *A;
  double *work;
  double *b;

  memory->create(xij, N, "eapod:xij");
  memory->create(S, N*ns, "eapod:S");
  memory->create(Q, N*ns, "eapod:Q");
  memory->create(A, ns*ns, "eapod:A");
  memory->create(work, ns*ns, "eapod:work");
  memory->create(b, ns, "eapod:ns");

  // Generate the xij array
  for (int i=0; i<N; i++)
    xij[i] = (rin+1e-6) + (rcut-rin-1e-6)*(i*1.0/(N-1));

  // Compute the snapshots matrix S
  snapshots(S, xij, N);

  // Compute the matrix A = S^T * S
  char chn = 'N';
  char cht = 'T';
  double alpha = 1.0, beta = 0.0;
  DGEMM(&cht, &chn, &ns, &ns, &N, &alpha, S, &N, S, &N, &beta, A, &ns);

  // Normalize the matrix A by dividing by N
  for (int i=0; i<ns*ns; i++)
    A[i] = A[i]*(1.0/N);

  // Compute the eigenvectors and eigenvalues of A
  int lwork = ns * ns;  // the length of the array work, lwork >= max(1,3*N-1)
  int info = 1;     // = 0:  successful exit
  //double work[ns*ns];
  char chv = 'V';
  char chu = 'U';
  DSYEV(&chv, &chu, &ns, A, &ns, b, work, &lwork, &info);

  // Order eigenvalues and eigenvectors from largest to smallest
  for (int j=0; j<ns; j++)
    for (int i=0; i<ns; i++)
      Phi[i + ns*(ns-j-1)] = A[i + ns*j];

  for (int i=0; i<ns; i++)
    Lambda[(ns-i-1)] = b[i];

  // Compute the matrix Q = S * Phi
  DGEMM(&chn, &chn, &N, &ns, &ns, &alpha, S, &N, Phi, &ns, &beta, Q, &N);

  // Compute the area of each snapshot and normalize the eigenvectors
  for (int i=0; i<(N-1); i++)
    xij[i] = xij[i+1] - xij[i];
  double area;
  for (int m=0; m<ns; m++) {
    area = 0.0;
    for (int i=0; i<(N-1); i++)
      area += 0.5*xij[i]*(Q[i + N*m]*Q[i + N*m] + Q[i+1 + N*m]*Q[i+1 + N*m]);
    for (int i=0; i<ns; i++)
      Phi[i + ns*m] = Phi[i + ns*m]/sqrt(area);
  }

  // Enforce consistent signs for the eigenvectors
  for (int m=0; m<ns; m++) {
    if (Phi[m + ns*m] < 0.0) {
      for (int i=0; i<ns; i++)
        Phi[i + ns*m] = -Phi[i + ns*m];
    }
  }

  // Free temporary arrays
  memory->destroy(xij);
  memory->destroy(S);
  memory->destroy(A);
  memory->destroy(work);
  memory->destroy(b);
  memory->destroy(Q);
}

/**
 * @brief Initialize the two-body coefficients.
 *
 * @param None
 */
void EAPOD::init2body()
{
  // Set the degree of the Bessel function and the inverse distance function
  pdegree[0] = besseldegree;
  pdegree[1] = inversedegree;

  // Compute the total number of snapshots
  ns = nbesselpars * pdegree[0] + pdegree[1];

  // Allocate memory for the eigenvectors and eigenvalues
  memory->create(Phi, ns * ns, "Phi");
  memory->create(Lambda, ns, "Lambda");

  // Perform eigenvalue decomposition of the snapshots matrix S and store the eigenvectors and eigenvalues
  eigenvaluedecomposition(Phi, Lambda, 2000);
}

/**
 * @brief Initialize arrays for the three-body descriptors.
 *
 * @param Pa3 The degree of the angular basis functions of the three-body descriptors.
 */
void EAPOD::init3body(int Pa3)
{
  // Define the number of monomials for each degree
  int npa[] = {0, 1, 4, 10, 20, 35, 56, 84, 120, 165, 220, 286, 364, 455};

  // Set the number of coefficients, the number of basis functions, and the degree of the Bessel function
  nabf3 = Pa3+1;    // Number of angular basis functions
  K3 = npa[nabf3];  // number of monimials
  P3 = nabf3-1;     // the degree of angular basis functions of the three-body descriptors

  // Allocate memory for the coefficients, the basis functions, and the cutoff function
  memory->create(pn3, nabf3+1, "pn3"); // array stores the number of monomials for each degree
  memory->create(pq3, K3*2, "pq3"); // array needed for the recursive computation of the angular basis functions
  memory->create(pc3, K3, "pc3");   // array needed for the computation of the three-body descriptors

  // Initialize the arrays
  init3bodyarray(pn3, pq3, pc3, nabf3-1);
}

/**
 * @brief Initialize arrays for the four-body descriptors.
 *
 * @param Pa4 The degree of the angular basis functions of the four-body descriptors.
 */
void EAPOD::init4body(int Pa4)
{
  // Define the number of monomials for each degree
  int npa[] = {0, 1, 4, 10, 20, 35, 56, 84, 120, 165, 220, 286, 364, 455};

  // Define the number of angular basis functions for each degree
  int nb[] = {1,     2,     4,     7,    11,    16,    23};

  // Define the number of terms needed to compute angular basis functions
  int ns[] = {0, 1, 4, 10, 19, 29, 47, 74, 89, 119, 155, 209, 230, 275, 335, 425, 533, 561, 624, 714, 849, 949, 1129, 1345};

  // Set the degree of the angular basis functions of the four-body descriptors
  P4 = Pa4;

  // Set the number of monomials for the angular basis functions of the four-body descriptors
  K4 = npa[Pa4+1];

  // Allocate memory for the output arrays
  int *pn4, *tm4;
  memory->create(pn4, Pa4+2, "pn4"); // array stores the number of monomials for each degree
  memory->create(pq4, K4*2, "pq4");  // array needed for the recursive computation of the angular basis functions
  memory->create(tm4, K4, "tm4");

  // Initialize the arrays
  init3bodyarray(pn4, pq4, tm4, Pa4);

  // Set the number of angular basis functions for the four-body descriptors
  nabf4 = nb[Pa4];

  // the size of the array pc4
  Q4 = ns[nabf4];

  // Allocate memory for the coefficients, the basis functions, and the cutoff function
  memory->create(pa4, nabf4+1, "pa4"); // this array is a subset of the array ns
  memory->create(pb4, Q4*3, "pb4"); // array stores the indices of the monomials needed for the computation of the angular basis functions
  memory->create(pc4, Q4, "pc4");   // array of monomial coefficients needed for the computation of the four-body descriptors

  // Initialize the arrays
  init4bodyarray(pa4, pb4, pc4, Pa4);

  // Deallocate memory
  memory->destroy(pn4);
  memory->destroy(tm4);
}


/**
 * @brief Estimate the amount of memory needed for the computation.
 *
 * @param Nj Number of neighboring atoms.
 * @return int The estimated amount of memory needed.
 */
int EAPOD::estimate_temp_memory(int Nj)
{
  // Determine the maximum number of radial basis functions and angular basis functions
  int Kmax = (K3 > K4) ? K3 : K4;
  int nrbf34 = (nrbf3 > nrbf4) ? nrbf3 : nrbf4;
  int nrbfmax = (nrbf2 > nrbf34) ? nrbf2 : nrbf34;
  int Knrbf34 = (K3*nrbf3 > K4*nrbf4) ? K3*nrbf3 : K4*nrbf4;

  // Determine the maximum number of local descriptors
  int nld = (nl23 > nl33) ? nl23 : nl33;
  nld = (nld > nl34) ? nld : nl34;
  nld = (nld > nl44) ? nld : nl44;

  // rij, fij, and d2, dd2, d3, dd3, d4, dd4
  int nmax1 = 6*Nj + nl2 + 3*Nj*nl2 + nl3 + 3*Nj*nl3 + nl4 + 3*Nj*nl4 + nld + 3*Nj*nld;

  // U, Ux, Uy, Uz
  int nmax2 = 4*Nj*Knrbf34;

  // sumU and cU
  int nmax3 = 2*nelements*Knrbf34;

  // rbf, rbfx, rbfy, rbfz
  int nmax4 = 4*Nj*nrbfmax;

  // rbft, rbfxt, rbfyt, rbfzt
  int nmax5 = 4*Nj*ns;

  // abf, abfx, abfy, abfz
  int nmax6 = 4*(Nj+1)*Kmax;

  // Determine the maximum amount of memory needed for U, Ux, Uy, Uz, sumU, cU, rbf, rbfx, rbfy, rbfz, abf, abfx, abfy, abfz
  int nmax7 = (nmax5 > nmax6) ? nmax5 : nmax6;
  int nmax8 = nmax2 + nmax3 + nmax4 + nmax7;

  // Determine the total amount of memory needed for all double memory
  ndblmem = (nmax1 + nmax8);

  int nmax9 = 6*Nj + nComponents + nClusters + nClusters*nComponents + 2*nClusters*Mdesc + nClusters*nClusters;
  if (ndblmem < nmax9) ndblmem = nmax9;

  // Determine the total amount of memory needed for all integer memory
  nintmem = 4*Nj;

  // Return the estimated amount of memory needed
  return ndblmem;
}

void EAPOD::allocate_temp_memory(int Nj)
{
  estimate_temp_memory(Nj);
  memory->create(tmpmem, ndblmem, "tmpmem");
  memory->create(tmpint, nintmem, "tmpint");
  memory->create(bd, Mdesc, "bdd");
  memory->create(bdd, 3*Nj*Mdesc, "bdd");
  memory->create(pd, nClusters, "bdd");
  memory->create(pdd, 3*Nj*nClusters, "bdd");
}

void EAPOD::free_temp_memory()
{
  memory->destroy(tmpmem);
  memory->destroy(tmpint);
  memory->destroy(bd);
  memory->destroy(bdd);
  memory->destroy(pd);
  memory->destroy(pdd);
}

/**
 * @brief Map a 3D index to a 1D index.
 *
 * @param indx The 1D index array.
 * @param n1 The size of the first dimension.
 * @param n2 The size of the second dimension.
 * @param n3 The size of the third dimension.
 * @param N1 The stride of the first dimension.
 * @param N2 The stride of the second dimension.
 * @return int The total number of elements in the 1D index array.
 */
int EAPOD::indexmap3(int *indx, int n1, int n2, int n3, int N1, int N2)
{
  int k = 0;
  for (int i3=0; i3<n3; i3++)
    for (int i2=0; i2<n2; i2++)
      for (int i1=0; i1<n1; i1++)
      {
        // Map the 3D index to a 1D index
        indx[k] = i1 + N1*i2 + N1*N2*i3;
        k += 1;
      }

  // Return the total number of elements in the 1D index array
  return k;
}

/**
 * @brief Calculate the number of cross descriptors between two sets of descriptors.
 *
 * @param dabf1 Pointer to the array of degrees of angular basis functions of the first set of descriptors.
 * @param nabf1 Number of angular basis functions in the first set of descriptors.
 * @param nrbf1 Number of radial basis functions in the first set of descriptors.
 * @param nebf1 Number of element interactions in the first set of descriptors.
 * @param dabf2 Pointer to the array of degrees of angular basis functions of the second set of descriptors.
 * @param nabf2 Number of angular basis functions in the second set of descriptors.
 * @param nrbf2 Number of radial basis functions in the second set of descriptors.
 * @param nebf2 Number of element interactions in the second set descriptors.
 * @param dabf12 degree of angular basis functions for the cross descriptors
 * @param nrbf12 number of radial basis functions for the cross descriptors
 * @return int The number of cross descriptors between two sets of descriptors.
 */
int EAPOD::crossindices(int *dabf1, int nabf1, int nrbf1, int nebf1,
         int *dabf2, int nabf2, int nrbf2, int nebf2, int dabf12, int nrbf12)
{
  int n = 0;

  // Loop over the first set of descriptors
  for (int i1=0; i1<nebf1; i1++)
    for (int j1=0; j1<nrbf1; j1++)
      for (int k1=0; k1<nabf1; k1++) {
        int m1 = k1 + j1*nabf1;
        int a1 = dabf1[k1];
        // Loop over the second set of descriptors
        for (int i2=0; i2<nebf2; i2++)
          for (int j2=0; j2<nrbf2; j2++)
            for (int k2=0; k2<nabf2; k2++) {
              int m2 = k2 + j2*nabf2;
              int a2 = dabf2[k2];
              // Check if the sum of the angular degrees is less than or equal to dabf12,
              // the number of radial basis functions is less than nrbf12, and the indices are in the correct order
              if ((m2 >= m1) && (i2 >= i1) && (a1 + a2 <= dabf12) && (j1+j2 < nrbf12)) {
                n += 1;
              }
            }
      }

  return n;
}

/**
 * @brief Calculate the number of cross descriptors between two sets of descriptors and store the indices in two arrays.
 *
 * @param ind1 Pointer to the array of indices of the first set of descriptors.
 * @param ind2 Pointer to the array of indices of the second set of descriptors.
 * @param dabf1 Pointer to the array of degrees of angular basis functions of the first set of descriptors.
 * @param nabf1 Number of angular basis functions in the first set of descriptors.
 * @param nrbf1 Number of radial basis functions in the first set of descriptors.
 * @param nebf1 Number of element interactions in the first set of descriptors.
 * @param dabf2 Pointer to the array of degrees of angular basis functions of the second set of descriptors.
 * @param nabf2 Number of angular basis functions in the second set of descriptors.
 * @param nrbf2 Number of radial basis functions in the second set of descriptors.
 * @param nebf2 Number of element interactions in the second set descriptors.
 * @param dabf12 degree of angular basis functions for the cross descriptors
 * @param nrbf12 number of radial basis functions for the cross descriptors
 * @return int The number of cross descriptors between two sets of descriptors.
 */
int EAPOD::crossindices(int *ind1, int *ind2, int *dabf1, int nabf1, int nrbf1, int nebf1,
         int *dabf2, int nabf2, int nrbf2, int nebf2, int dabf12, int nrbf12)
{
  int n = 0;

  // Loop over the first set of descriptors
  for (int i1=0; i1<nebf1; i1++)
    for (int j1=0; j1<nrbf1; j1++)
      for (int k1=0; k1<nabf1; k1++) {
        int m1 = k1 + j1*nabf1;
        int n1 = m1 + i1*nabf1*nrbf1;
        int a1 = dabf1[k1];
        // Loop over the second set of descriptors
        for (int i2=0; i2<nebf2; i2++)
          for (int j2=0; j2<nrbf2; j2++)
            for (int k2=0; k2<nabf2; k2++) {
              int m2 = k2 + j2*nabf2;
              int n2 = m2 + i2*nabf2*nrbf2;
              int a2 = dabf2[k2];
              // Check if the sum of the angular degrees is less than or equal to dabf12,
              // the number of radial basis functions is less than nrbf12, and the indices are in the correct order
              if ((m2 >= m1) && (i2 >= i1) && (a1 + a2 <= dabf12) && (j1+j2 < nrbf12)) {
                ind1[n] = n1;
                ind2[n] = n2;
                n += 1;
              }
            }
      }

  return n;
}

void EAPOD::scalarproduct(double *d, double c, int N)
{
  for (int n=0; n<N; n++)
    d[n] = d[n]*c;
}

double EAPOD::dotproduct(double *c, double *d, int ndesc)
{
  double e = 0.0;
  for (int n = 0; n<ndesc; n++)
    e += d[n]*c[n];
  return e;
}

void EAPOD::mvproduct(double *fij, double *c, double *dd, int N, int ndesc)
{
  for (int m=0; m<ndesc; m++)
    for (int n=0; n<N; n++)
      fij[n] += dd[n + N*m]*c[m];
}

void EAPOD::MatMul(double *c, double *a, double *b, int r1, int c1, int c2)
{
  int i, j, k;

  for(j = 0; j < c2; j++)
    for(i = 0; i < r1; i++)
      c[i + r1*j] = 0.0;

  for(j = 0; j < c2; j++)
    for(i = 0; i < r1; i++)
      for(k = 0; k < c1; k++)
        c[i + r1*j] += a[i + r1*k] * b[k + c1*j];
}

void EAPOD::peratomenvironment_descriptors(double *P, double *dP_dR, double *B, double *dB_dR, double *tmp, int elem, int nNeighbors)
{
  double *ProjMat = &Proj[nComponents*Mdesc*elem];
  double *centroids = &Centroids[nComponents*nClusters*elem];
  double *pca = &tmp[0];
  double *D = &tmp[nComponents];
  double *dD_dpca = &tmp[nComponents + nClusters];
  double *dD_dB = &tmp[nComponents + nClusters + nClusters*nComponents];
  double *dP_dD = &tmp[nComponents + nClusters + nClusters*nComponents + nClusters*Mdesc];
  double *dP_dB = &tmp[nComponents + nClusters + nClusters*nComponents + nClusters*Mdesc + nClusters*nClusters];

  // calculate principal components
  for (int k = 0; k < nComponents; k++) {
    pca[k] = 0.0;
    for (int m = 0; m < Mdesc; m++) {
      pca[k] += ProjMat[k + nComponents*m] * B[m];
    }
  }

  // calculate inverse square distances
  double sumD = 0.0;
  for (int j = 0; j < nClusters; j++) {
    D[j] = 1e-20; // fix for zero distances
    for (int k = 0; k < nComponents; k++) {
      D[j] += (pca[k] - centroids[k + j * nComponents]) * (pca[k] - centroids[k + j * nComponents]);
    }
    D[j] = 1.0 / D[j];
    sumD += D[j];
  }

  // calculate probabilities
  for (int j = 0; j < nClusters; j++) {
    P[j] = D[j] / sumD;
  }

  // calculate dD_dpca
  for (int n = 0; n < nComponents; n++) {
    for (int k = 0; k < nClusters; k++) {
      dD_dpca[k + n * nClusters] = 2 * D[k] * D[k] * (centroids[n + k * nComponents] - pca[n]);
    }
  }

  // calculate dD_dB
  char chn = 'N';
  char cht = 'T';
  double alpha = 1.0, beta = 0.0;
  DGEMM(&chn, &chn, &nClusters, &Mdesc, &nComponents, &alpha, dD_dpca, &nClusters, ProjMat, &nComponents, &beta, dD_dB, &nClusters);

  // calculate dP_dD
  double S1 = 1.0 / sumD;
  double S2 = S1 * S1;
  for (int k = 0; k < nClusters; k++) {
    for (int j = 0; j < nClusters; j++) {
      dP_dD[j + k * nClusters] = -D[j] * S2;
    }
  }
  for (int j = 0; j < nClusters; j++) {
    dP_dD[j + j * nClusters] += S1;
  }

  // calculate dP_dB = dP_dD * dD_dB, which are derivatives of probabilities with respect to local descriptors
  DGEMM(&chn, &chn, &nClusters, &Mdesc, &nClusters, &alpha, dP_dD, &nClusters, dD_dB, &nClusters, &beta, dP_dB, &nClusters);

  // calculate dP_dR = dB_dR * dP_dB , which are derivatives of probabilities with respect to atomic coordinates
  int N = 3*nNeighbors;
  DGEMM(&chn, &cht, &N, &nClusters, &Mdesc, &alpha, dB_dR, &N, dP_dB, &nClusters, &beta, dP_dR, &N);
}

void EAPOD::init3bodyarray(int *np, int *pq, int *pc, int Pa)
{
  int npa[] = {0, 1, 4, 10, 20, 35, 56, 84, 120, 165, 220, 286, 364, 455};

  int poly[455][6] =
  {
    {0, 0, 0, 0, 0, 1},
    {1, 0, 0, 1, 1, 1},
    {0, 1, 0, 1, 2, 1},
    {0, 0, 1, 1, 3, 1},
    {2, 0, 0, 2, 1, 1},
    {1, 1, 0, 2, 2, 2},
    {0, 2, 0, 3, 2, 1},
    {1, 0, 1, 2, 3, 2},
    {0, 1, 1, 3, 3, 2},
    {0, 0, 2, 4, 3, 1},
    {3, 0, 0, 5, 1, 1},
    {2, 1, 0, 5, 2, 3},
    {1, 2, 0, 6, 2, 3},
    {0, 3, 0, 7, 2, 1},
    {2, 0, 1, 5, 3, 3},
    {1, 1, 1, 6, 3, 6},
    {0, 2, 1, 7, 3, 3},
    {1, 0, 2, 8, 3, 3},
    {0, 1, 2, 9, 3, 3},
    {0, 0, 3, 10, 3, 1},
    {4, 0, 0, 11, 1, 1},
    {3, 1, 0, 11, 2, 4},
    {2, 2, 0, 12, 2, 6},
    {1, 3, 0, 13, 2, 4},
    {0, 4, 0, 14, 2, 1},
    {3, 0, 1, 11, 3, 4},
    {2, 1, 1, 12, 3, 12},
    {1, 2, 1, 13, 3, 12},
    {0, 3, 1, 14, 3, 4},
    {2, 0, 2, 15, 3, 6},
    {1, 1, 2, 16, 3, 12},
    {0, 2, 2, 17, 3, 6},
    {1, 0, 3, 18, 3, 4},
    {0, 1, 3, 19, 3, 4},
    {0, 0, 4, 20, 3, 1},
    {5, 0, 0, 21, 1, 1},
    {4, 1, 0, 21, 2, 5},
    {3, 2, 0, 22, 2, 10},
    {2, 3, 0, 23, 2, 10},
    {1, 4, 0, 24, 2, 5},
    {0, 5, 0, 25, 2, 1},
    {4, 0, 1, 21, 3, 5},
    {3, 1, 1, 22, 3, 20},
    {2, 2, 1, 23, 3, 30},
    {1, 3, 1, 24, 3, 20},
    {0, 4, 1, 25, 3, 5},
    {3, 0, 2, 26, 3, 10},
    {2, 1, 2, 27, 3, 30},
    {1, 2, 2, 28, 3, 30},
    {0, 3, 2, 29, 3, 10},
    {2, 0, 3, 30, 3, 10},
    {1, 1, 3, 31, 3, 20},
    {0, 2, 3, 32, 3, 10},
    {1, 0, 4, 33, 3, 5},
    {0, 1, 4, 34, 3, 5},
    {0, 0, 5, 35, 3, 1},
    {6, 0, 0, 36, 1, 1},
    {5, 1, 0, 36, 2, 6},
    {4, 2, 0, 37, 2, 15},
    {3, 3, 0, 38, 2, 20},
    {2, 4, 0, 39, 2, 15},
    {1, 5, 0, 40, 2, 6},
    {0, 6, 0, 41, 2, 1},
    {5, 0, 1, 36, 3, 6},
    {4, 1, 1, 37, 3, 30},
    {3, 2, 1, 38, 3, 60},
    {2, 3, 1, 39, 3, 60},
    {1, 4, 1, 40, 3, 30},
    {0, 5, 1, 41, 3, 6},
    {4, 0, 2, 42, 3, 15},
    {3, 1, 2, 43, 3, 60},
    {2, 2, 2, 44, 3, 90},
    {1, 3, 2, 45, 3, 60},
    {0, 4, 2, 46, 3, 15},
    {3, 0, 3, 47, 3, 20},
    {2, 1, 3, 48, 3, 60},
    {1, 2, 3, 49, 3, 60},
    {0, 3, 3, 50, 3, 20},
    {2, 0, 4, 51, 3, 15},
    {1, 1, 4, 52, 3, 30},
    {0, 2, 4, 53, 3, 15},
    {1, 0, 5, 54, 3, 6},
    {0, 1, 5, 55, 3, 6},
    {0, 0, 6, 56, 3, 1},
    {7, 0, 0, 57, 1, 1},
    {6, 1, 0, 57, 2, 7},
    {5, 2, 0, 58, 2, 21},
    {4, 3, 0, 59, 2, 35},
    {3, 4, 0, 60, 2, 35},
    {2, 5, 0, 61, 2, 21},
    {1, 6, 0, 62, 2, 7},
    {0, 7, 0, 63, 2, 1},
    {6, 0, 1, 57, 3, 7},
    {5, 1, 1, 58, 3, 42},
    {4, 2, 1, 59, 3, 105},
    {3, 3, 1, 60, 3, 140},
    {2, 4, 1, 61, 3, 105},
    {1, 5, 1, 62, 3, 42},
    {0, 6, 1, 63, 3, 7},
    {5, 0, 2, 64, 3, 21},
    {4, 1, 2, 65, 3, 105},
    {3, 2, 2, 66, 3, 210},
    {2, 3, 2, 67, 3, 210},
    {1, 4, 2, 68, 3, 105},
    {0, 5, 2, 69, 3, 21},
    {4, 0, 3, 70, 3, 35},
    {3, 1, 3, 71, 3, 140},
    {2, 2, 3, 72, 3, 210},
    {1, 3, 3, 73, 3, 140},
    {0, 4, 3, 74, 3, 35},
    {3, 0, 4, 75, 3, 35},
    {2, 1, 4, 76, 3, 105},
    {1, 2, 4, 77, 3, 105},
    {0, 3, 4, 78, 3, 35},
    {2, 0, 5, 79, 3, 21},
    {1, 1, 5, 80, 3, 42},
    {0, 2, 5, 81, 3, 21},
    {1, 0, 6, 82, 3, 7},
    {0, 1, 6, 83, 3, 7},
    {0, 0, 7, 84, 3, 1},
    {8, 0, 0, 85, 1, 1},
    {7, 1, 0, 85, 2, 8},
    {6, 2, 0, 86, 2, 28},
    {5, 3, 0, 87, 2, 56},
    {4, 4, 0, 88, 2, 70},
    {3, 5, 0, 89, 2, 56},
    {2, 6, 0, 90, 2, 28},
    {1, 7, 0, 91, 2, 8},
    {0, 8, 0, 92, 2, 1},
    {7, 0, 1, 85, 3, 8},
    {6, 1, 1, 86, 3, 56},
    {5, 2, 1, 87, 3, 168},
    {4, 3, 1, 88, 3, 280},
    {3, 4, 1, 89, 3, 280},
    {2, 5, 1, 90, 3, 168},
    {1, 6, 1, 91, 3, 56},
    {0, 7, 1, 92, 3, 8},
    {6, 0, 2, 93, 3, 28},
    {5, 1, 2, 94, 3, 168},
    {4, 2, 2, 95, 3, 420},
    {3, 3, 2, 96, 3, 560},
    {2, 4, 2, 97, 3, 420},
    {1, 5, 2, 98, 3, 168},
    {0, 6, 2, 99, 3, 28},
    {5, 0, 3, 100, 3, 56},
    {4, 1, 3, 101, 3, 280},
    {3, 2, 3, 102, 3, 560},
    {2, 3, 3, 103, 3, 560},
    {1, 4, 3, 104, 3, 280},
    {0, 5, 3, 105, 3, 56},
    {4, 0, 4, 106, 3, 70},
    {3, 1, 4, 107, 3, 280},
    {2, 2, 4, 108, 3, 420},
    {1, 3, 4, 109, 3, 280},
    {0, 4, 4, 110, 3, 70},
    {3, 0, 5, 111, 3, 56},
    {2, 1, 5, 112, 3, 168},
    {1, 2, 5, 113, 3, 168},
    {0, 3, 5, 114, 3, 56},
    {2, 0, 6, 115, 3, 28},
    {1, 1, 6, 116, 3, 56},
    {0, 2, 6, 117, 3, 28},
    {1, 0, 7, 118, 3, 8},
    {0, 1, 7, 119, 3, 8},
    {0, 0, 8, 120, 3, 1},
    {9, 0, 0, 121, 1, 1},
    {8, 1, 0, 121, 2, 9},
    {7, 2, 0, 122, 2, 36},
    {6, 3, 0, 123, 2, 84},
    {5, 4, 0, 124, 2, 126},
    {4, 5, 0, 125, 2, 126},
    {3, 6, 0, 126, 2, 84},
    {2, 7, 0, 127, 2, 36},
    {1, 8, 0, 128, 2, 9},
    {0, 9, 0, 129, 2, 1},
    {8, 0, 1, 121, 3, 9},
    {7, 1, 1, 122, 3, 72},
    {6, 2, 1, 123, 3, 252},
    {5, 3, 1, 124, 3, 504},
    {4, 4, 1, 125, 3, 630},
    {3, 5, 1, 126, 3, 504},
    {2, 6, 1, 127, 3, 252},
    {1, 7, 1, 128, 3, 72},
    {0, 8, 1, 129, 3, 9},
    {7, 0, 2, 130, 3, 36},
    {6, 1, 2, 131, 3, 252},
    {5, 2, 2, 132, 3, 756},
    {4, 3, 2, 133, 3, 1260},
    {3, 4, 2, 134, 3, 1260},
    {2, 5, 2, 135, 3, 756},
    {1, 6, 2, 136, 3, 252},
    {0, 7, 2, 137, 3, 36},
    {6, 0, 3, 138, 3, 84},
    {5, 1, 3, 139, 3, 504},
    {4, 2, 3, 140, 3, 1260},
    {3, 3, 3, 141, 3, 1680},
    {2, 4, 3, 142, 3, 1260},
    {1, 5, 3, 143, 3, 504},
    {0, 6, 3, 144, 3, 84},
    {5, 0, 4, 145, 3, 126},
    {4, 1, 4, 146, 3, 630},
    {3, 2, 4, 147, 3, 1260},
    {2, 3, 4, 148, 3, 1260},
    {1, 4, 4, 149, 3, 630},
    {0, 5, 4, 150, 3, 126},
    {4, 0, 5, 151, 3, 126},
    {3, 1, 5, 152, 3, 504},
    {2, 2, 5, 153, 3, 756},
    {1, 3, 5, 154, 3, 504},
    {0, 4, 5, 155, 3, 126},
    {3, 0, 6, 156, 3, 84},
    {2, 1, 6, 157, 3, 252},
    {1, 2, 6, 158, 3, 252},
    {0, 3, 6, 159, 3, 84},
    {2, 0, 7, 160, 3, 36},
    {1, 1, 7, 161, 3, 72},
    {0, 2, 7, 162, 3, 36},
    {1, 0, 8, 163, 3, 9},
    {0, 1, 8, 164, 3, 9},
    {0, 0, 9, 165, 3, 1},
    {10, 0, 0, 166, 1, 1},
    {9, 1, 0, 166, 2, 10},
    {8, 2, 0, 167, 2, 45},
    {7, 3, 0, 168, 2, 120},
    {6, 4, 0, 169, 2, 210},
    {5, 5, 0, 170, 2, 252},
    {4, 6, 0, 171, 2, 210},
    {3, 7, 0, 172, 2, 120},
    {2, 8, 0, 173, 2, 45},
    {1, 9, 0, 174, 2, 10},
    {0, 10, 0, 175, 2, 1},
    {9, 0, 1, 166, 3, 10},
    {8, 1, 1, 167, 3, 90},
    {7, 2, 1, 168, 3, 360},
    {6, 3, 1, 169, 3, 840},
    {5, 4, 1, 170, 3, 1260},
    {4, 5, 1, 171, 3, 1260},
    {3, 6, 1, 172, 3, 840},
    {2, 7, 1, 173, 3, 360},
    {1, 8, 1, 174, 3, 90},
    {0, 9, 1, 175, 3, 10},
    {8, 0, 2, 176, 3, 45},
    {7, 1, 2, 177, 3, 360},
    {6, 2, 2, 178, 3, 1260},
    {5, 3, 2, 179, 3, 2520},
    {4, 4, 2, 180, 3, 3150},
    {3, 5, 2, 181, 3, 2520},
    {2, 6, 2, 182, 3, 1260},
    {1, 7, 2, 183, 3, 360},
    {0, 8, 2, 184, 3, 45},
    {7, 0, 3, 185, 3, 120},
    {6, 1, 3, 186, 3, 840},
    {5, 2, 3, 187, 3, 2520},
    {4, 3, 3, 188, 3, 4200},
    {3, 4, 3, 189, 3, 4200},
    {2, 5, 3, 190, 3, 2520},
    {1, 6, 3, 191, 3, 840},
    {0, 7, 3, 192, 3, 120},
    {6, 0, 4, 193, 3, 210},
    {5, 1, 4, 194, 3, 1260},
    {4, 2, 4, 195, 3, 3150},
    {3, 3, 4, 196, 3, 4200},
    {2, 4, 4, 197, 3, 3150},
    {1, 5, 4, 198, 3, 1260},
    {0, 6, 4, 199, 3, 210},
    {5, 0, 5, 200, 3, 252},
    {4, 1, 5, 201, 3, 1260},
    {3, 2, 5, 202, 3, 2520},
    {2, 3, 5, 203, 3, 2520},
    {1, 4, 5, 204, 3, 1260},
    {0, 5, 5, 205, 3, 252},
    {4, 0, 6, 206, 3, 210},
    {3, 1, 6, 207, 3, 840},
    {2, 2, 6, 208, 3, 1260},
    {1, 3, 6, 209, 3, 840},
    {0, 4, 6, 210, 3, 210},
    {3, 0, 7, 211, 3, 120},
    {2, 1, 7, 212, 3, 360},
    {1, 2, 7, 213, 3, 360},
    {0, 3, 7, 214, 3, 120},
    {2, 0, 8, 215, 3, 45},
    {1, 1, 8, 216, 3, 90},
    {0, 2, 8, 217, 3, 45},
    {1, 0, 9, 218, 3, 10},
    {0, 1, 9, 219, 3, 10},
    {0, 0, 10, 220, 3, 1},
    {11, 0, 0, 221, 1, 1},
    {10, 1, 0, 221, 2, 11},
    {9, 2, 0, 222, 2, 55},
    {8, 3, 0, 223, 2, 165},
    {7, 4, 0, 224, 2, 330},
    {6, 5, 0, 225, 2, 462},
    {5, 6, 0, 226, 2, 462},
    {4, 7, 0, 227, 2, 330},
    {3, 8, 0, 228, 2, 165},
    {2, 9, 0, 229, 2, 55},
    {1, 10, 0, 230, 2, 11},
    {0, 11, 0, 231, 2, 1},
    {10, 0, 1, 221, 3, 11},
    {9, 1, 1, 222, 3, 110},
    {8, 2, 1, 223, 3, 495},
    {7, 3, 1, 224, 3, 1320},
    {6, 4, 1, 225, 3, 2310},
    {5, 5, 1, 226, 3, 2772},
    {4, 6, 1, 227, 3, 2310},
    {3, 7, 1, 228, 3, 1320},
    {2, 8, 1, 229, 3, 495},
    {1, 9, 1, 230, 3, 110},
    {0, 10, 1, 231, 3, 11},
    {9, 0, 2, 232, 3, 55},
    {8, 1, 2, 233, 3, 495},
    {7, 2, 2, 234, 3, 1980},
    {6, 3, 2, 235, 3, 4620},
    {5, 4, 2, 236, 3, 6930},
    {4, 5, 2, 237, 3, 6930},
    {3, 6, 2, 238, 3, 4620},
    {2, 7, 2, 239, 3, 1980},
    {1, 8, 2, 240, 3, 495},
    {0, 9, 2, 241, 3, 55},
    {8, 0, 3, 242, 3, 165},
    {7, 1, 3, 243, 3, 1320},
    {6, 2, 3, 244, 3, 4620},
    {5, 3, 3, 245, 3, 9240},
    {4, 4, 3, 246, 3, 11550},
    {3, 5, 3, 247, 3, 9240},
    {2, 6, 3, 248, 3, 4620},
    {1, 7, 3, 249, 3, 1320},
    {0, 8, 3, 250, 3, 165},
    {7, 0, 4, 251, 3, 330},
    {6, 1, 4, 252, 3, 2310},
    {5, 2, 4, 253, 3, 6930},
    {4, 3, 4, 254, 3, 11550},
    {3, 4, 4, 255, 3, 11550},
    {2, 5, 4, 256, 3, 6930},
    {1, 6, 4, 257, 3, 2310},
    {0, 7, 4, 258, 3, 330},
    {6, 0, 5, 259, 3, 462},
    {5, 1, 5, 260, 3, 2772},
    {4, 2, 5, 261, 3, 6930},
    {3, 3, 5, 262, 3, 9240},
    {2, 4, 5, 263, 3, 6930},
    {1, 5, 5, 264, 3, 2772},
    {0, 6, 5, 265, 3, 462},
    {5, 0, 6, 266, 3, 462},
    {4, 1, 6, 267, 3, 2310},
    {3, 2, 6, 268, 3, 4620},
    {2, 3, 6, 269, 3, 4620},
    {1, 4, 6, 270, 3, 2310},
    {0, 5, 6, 271, 3, 462},
    {4, 0, 7, 272, 3, 330},
    {3, 1, 7, 273, 3, 1320},
    {2, 2, 7, 274, 3, 1980},
    {1, 3, 7, 275, 3, 1320},
    {0, 4, 7, 276, 3, 330},
    {3, 0, 8, 277, 3, 165},
    {2, 1, 8, 278, 3, 495},
    {1, 2, 8, 279, 3, 495},
    {0, 3, 8, 280, 3, 165},
    {2, 0, 9, 281, 3, 55},
    {1, 1, 9, 282, 3, 110},
    {0, 2, 9, 283, 3, 55},
    {1, 0, 10, 284, 3, 11},
    {0, 1, 10, 285, 3, 11},
    {0, 0, 11, 286, 3, 1},
    {12, 0, 0, 287, 1, 1},
    {11, 1, 0, 287, 2, 12},
    {10, 2, 0, 288, 2, 66},
    {9, 3, 0, 289, 2, 220},
    {8, 4, 0, 290, 2, 495},
    {7, 5, 0, 291, 2, 792},
    {6, 6, 0, 292, 2, 924},
    {5, 7, 0, 293, 2, 792},
    {4, 8, 0, 294, 2, 495},
    {3, 9, 0, 295, 2, 220},
    {2, 10, 0, 296, 2, 66},
    {1, 11, 0, 297, 2, 12},
    {0, 12, 0, 298, 2, 1},
    {11, 0, 1, 287, 3, 12},
    {10, 1, 1, 288, 3, 132},
    {9, 2, 1, 289, 3, 660},
    {8, 3, 1, 290, 3, 1980},
    {7, 4, 1, 291, 3, 3960},
    {6, 5, 1, 292, 3, 5544},
    {5, 6, 1, 293, 3, 5544},
    {4, 7, 1, 294, 3, 3960},
    {3, 8, 1, 295, 3, 1980},
    {2, 9, 1, 296, 3, 660},
    {1, 10, 1, 297, 3, 132},
    {0, 11, 1, 298, 3, 12},
    {10, 0, 2, 299, 3, 66},
    {9, 1, 2, 300, 3, 660},
    {8, 2, 2, 301, 3, 2970},
    {7, 3, 2, 302, 3, 7920},
    {6, 4, 2, 303, 3, 13860},
    {5, 5, 2, 304, 3, 16632},
    {4, 6, 2, 305, 3, 13860},
    {3, 7, 2, 306, 3, 7920},
    {2, 8, 2, 307, 3, 2970},
    {1, 9, 2, 308, 3, 660},
    {0, 10, 2, 309, 3, 66},
    {9, 0, 3, 310, 3, 220},
    {8, 1, 3, 311, 3, 1980},
    {7, 2, 3, 312, 3, 7920},
    {6, 3, 3, 313, 3, 18480},
    {5, 4, 3, 314, 3, 27720},
    {4, 5, 3, 315, 3, 27720},
    {3, 6, 3, 316, 3, 18480},
    {2, 7, 3, 317, 3, 7920},
    {1, 8, 3, 318, 3, 1980},
    {0, 9, 3, 319, 3, 220},
    {8, 0, 4, 320, 3, 495},
    {7, 1, 4, 321, 3, 3960},
    {6, 2, 4, 322, 3, 13860},
    {5, 3, 4, 323, 3, 27720},
    {4, 4, 4, 324, 3, 34650},
    {3, 5, 4, 325, 3, 27720},
    {2, 6, 4, 326, 3, 13860},
    {1, 7, 4, 327, 3, 3960},
    {0, 8, 4, 328, 3, 495},
    {7, 0, 5, 329, 3, 792},
    {6, 1, 5, 330, 3, 5544},
    {5, 2, 5, 331, 3, 16632},
    {4, 3, 5, 332, 3, 27720},
    {3, 4, 5, 333, 3, 27720},
    {2, 5, 5, 334, 3, 16632},
    {1, 6, 5, 335, 3, 5544},
    {0, 7, 5, 336, 3, 792},
    {6, 0, 6, 337, 3, 924},
    {5, 1, 6, 338, 3, 5544},
    {4, 2, 6, 339, 3, 13860},
    {3, 3, 6, 340, 3, 18480},
    {2, 4, 6, 341, 3, 13860},
    {1, 5, 6, 342, 3, 5544},
    {0, 6, 6, 343, 3, 924},
    {5, 0, 7, 344, 3, 792},
    {4, 1, 7, 345, 3, 3960},
    {3, 2, 7, 346, 3, 7920},
    {2, 3, 7, 347, 3, 7920},
    {1, 4, 7, 348, 3, 3960},
    {0, 5, 7, 349, 3, 792},
    {4, 0, 8, 350, 3, 495},
    {3, 1, 8, 351, 3, 1980},
    {2, 2, 8, 352, 3, 2970},
    {1, 3, 8, 353, 3, 1980},
    {0, 4, 8, 354, 3, 495},
    {3, 0, 9, 355, 3, 220},
    {2, 1, 9, 356, 3, 660},
    {1, 2, 9, 357, 3, 660},
    {0, 3, 9, 358, 3, 220},
    {2, 0, 10, 359, 3, 66},
    {1, 1, 10, 360, 3, 132},
    {0, 2, 10, 361, 3, 66},
    {1, 0, 11, 362, 3, 12},
    {0, 1, 11, 363, 3, 12},
    {0, 0, 12, 364, 3, 1}
  };

  for (int i = 0; i<= Pa+1; i++)
    np[i] = npa[i];

  int nmax = np[Pa+1];

  for (int i=0; i<nmax; i++) {
    pq[i]        = poly[i][3];
    pq[i+nmax]   = poly[i][4];
    pc[i]        = poly[i][5];
  }
}

void EAPOD::init4bodyarray(int *ns4, int *pb4, int *pc4, int Pa)
{
  int nb[] = {1,     2,     4,     7,    11,    16,    23};

  int ns[] =
  {
    0,
    1,
    4,
    10,
    19,
    29,
    47,
    74,
    89,
    119,
    155,
    209,
    230,
    275,
    335,
    425,
    533,
    561,
    624,
    714,
    849,
    949,
    1129,
    1345
  };

  int poly[1345][4] =
  {
    {1, 1, 1, 1},
    {2, 2, 1, 1},
    {3, 3, 1, 1},
    {4, 4, 1, 1},
    {5, 5, 1, 1},
    {6, 6, 1, 2},
    {8, 8, 1, 2},
    {7, 7, 1, 1},
    {9, 9, 1, 2},
    {10, 10, 1, 1},
    {5, 2, 2, 1},
    {6, 2, 3, 1},
    {6, 3, 2, 1},
    {8, 2, 4, 1},
    {8, 4, 2, 1},
    {7, 3, 3, 1},
    {9, 3, 4, 1},
    {9, 4, 3, 1},
    {10, 4, 4, 1},
    {11, 11, 1, 1},
    {12, 12, 1, 3},
    {15, 15, 1, 3},
    {13, 13, 1, 3},
    {16, 16, 1, 6},
    {18, 18, 1, 3},
    {14, 14, 1, 1},
    {17, 17, 1, 3},
    {19, 19, 1, 3},
    {20, 20, 1, 1},
    {11, 5, 2, 1},
    {12, 5, 3, 1},
    {12, 6, 2, 2},
    {15, 5, 4, 1},
    {15, 8, 2, 2},
    {13, 6, 3, 2},
    {13, 7, 2, 1},
    {16, 6, 4, 2},
    {16, 8, 3, 2},
    {16, 9, 2, 2},
    {18, 8, 4, 2},
    {18, 10, 2, 1},
    {14, 7, 3, 1},
    {17, 7, 4, 1},
    {17, 9, 3, 2},
    {19, 9, 4, 2},
    {19, 10, 3, 1},
    {20, 10, 4, 1},
    {5, 5, 5, 1},
    {5, 6, 6, 1},
    {5, 8, 8, 1},
    {6, 5, 6, 1},
    {6, 6, 5, 1},
    {6, 6, 7, 1},
    {6, 8, 9, 1},
    {6, 7, 6, 1},
    {6, 9, 8, 1},
    {8, 5, 8, 1},
    {8, 6, 9, 1},
    {8, 8, 5, 1},
    {8, 8, 10, 1},
    {8, 9, 6, 1},
    {8, 10, 8, 1},
    {7, 6, 6, 1},
    {7, 7, 7, 1},
    {7, 9, 9, 1},
    {9, 6, 8, 1},
    {9, 8, 6, 1},
    {9, 7, 9, 1},
    {9, 9, 7, 1},
    {9, 9, 10, 1},
    {9, 10, 9, 1},
    {10, 8, 8, 1},
    {10, 9, 9, 1},
    {10, 10, 10, 1},
    {21, 21, 1, 1},
    {22, 22, 1, 4},
    {26, 26, 1, 4},
    {23, 23, 1, 6},
    {27, 27, 1, 12},
    {30, 30, 1, 6},
    {24, 24, 1, 4},
    {28, 28, 1, 12},
    {31, 31, 1, 12},
    {33, 33, 1, 4},
    {25, 25, 1, 1},
    {29, 29, 1, 4},
    {32, 32, 1, 6},
    {34, 34, 1, 4},
    {35, 35, 1, 1},
    {21, 11, 2, 1},
    {22, 11, 3, 1},
    {22, 12, 2, 3},
    {26, 11, 4, 1},
    {26, 15, 2, 3},
    {23, 12, 3, 3},
    {23, 13, 2, 3},
    {27, 12, 4, 3},
    {27, 15, 3, 3},
    {27, 16, 2, 6},
    {30, 15, 4, 3},
    {30, 18, 2, 3},
    {24, 13, 3, 3},
    {24, 14, 2, 1},
    {28, 13, 4, 3},
    {28, 16, 3, 6},
    {28, 17, 2, 3},
    {31, 16, 4, 6},
    {31, 18, 3, 3},
    {31, 19, 2, 3},
    {33, 18, 4, 3},
    {33, 20, 2, 1},
    {25, 14, 3, 1},
    {29, 14, 4, 1},
    {29, 17, 3, 3},
    {32, 17, 4, 3},
    {32, 19, 3, 3},
    {34, 19, 4, 3},
    {34, 20, 3, 1},
    {35, 20, 4, 1},
    {21, 5, 5, 1},
    {22, 5, 6, 2},
    {22, 6, 5, 2},
    {26, 5, 8, 2},
    {26, 8, 5, 2},
    {23, 5, 7, 1},
    {23, 6, 6, 4},
    {23, 7, 5, 1},
    {27, 5, 9, 2},
    {27, 6, 8, 4},
    {27, 8, 6, 4},
    {27, 9, 5, 2},
    {30, 5, 10, 1},
    {30, 8, 8, 4},
    {30, 10, 5, 1},
    {24, 6, 7, 2},
    {24, 7, 6, 2},
    {28, 6, 9, 4},
    {28, 8, 7, 2},
    {28, 7, 8, 2},
    {28, 9, 6, 4},
    {31, 6, 10, 2},
    {31, 8, 9, 4},
    {31, 9, 8, 4},
    {31, 10, 6, 2},
    {33, 8, 10, 2},
    {33, 10, 8, 2},
    {25, 7, 7, 1},
    {29, 7, 9, 2},
    {29, 9, 7, 2},
    {32, 7, 10, 1},
    {32, 9, 9, 4},
    {32, 10, 7, 1},
    {34, 9, 10, 2},
    {34, 10, 9, 2},
    {35, 10, 10, 1},
    {11, 11, 5, 1},
    {11, 12, 6, 1},
    {11, 15, 8, 1},
    {12, 11, 6, 1},
    {12, 12, 5, 2},
    {12, 12, 7, 1},
    {12, 15, 9, 1},
    {12, 13, 6, 2},
    {12, 16, 8, 2},
    {15, 11, 8, 1},
    {15, 12, 9, 1},
    {15, 15, 5, 2},
    {15, 15, 10, 1},
    {15, 16, 6, 2},
    {15, 18, 8, 2},
    {13, 12, 6, 2},
    {13, 13, 5, 1},
    {13, 13, 7, 2},
    {13, 16, 9, 2},
    {13, 14, 6, 1},
    {13, 17, 8, 1},
    {16, 12, 8, 2},
    {16, 15, 6, 2},
    {16, 13, 9, 2},
    {16, 16, 5, 2},
    {16, 16, 7, 2},
    {16, 16, 10, 2},
    {16, 18, 9, 2},
    {16, 17, 6, 2},
    {16, 19, 8, 2},
    {18, 15, 8, 2},
    {18, 16, 9, 2},
    {18, 18, 5, 1},
    {18, 18, 10, 2},
    {18, 19, 6, 1},
    {18, 20, 8, 1},
    {14, 13, 6, 1},
    {14, 14, 7, 1},
    {14, 17, 9, 1},
    {17, 13, 8, 1},
    {17, 16, 6, 2},
    {17, 14, 9, 1},
    {17, 17, 7, 2},
    {17, 17, 10, 1},
    {17, 19, 9, 2},
    {19, 16, 8, 2},
    {19, 18, 6, 1},
    {19, 17, 9, 2},
    {19, 19, 7, 1},
    {19, 19, 10, 2},
    {19, 20, 9, 1},
    {20, 18, 8, 1},
    {20, 19, 9, 1},
    {20, 20, 10, 1},
    {36, 36, 1, 1},
    {37, 37, 1, 5},
    {42, 42, 1, 5},
    {38, 38, 1, 10},
    {43, 43, 1, 20},
    {47, 47, 1, 10},
    {39, 39, 1, 10},
    {44, 44, 1, 30},
    {48, 48, 1, 30},
    {51, 51, 1, 10},
    {40, 40, 1, 5},
    {45, 45, 1, 20},
    {49, 49, 1, 30},
    {52, 52, 1, 20},
    {54, 54, 1, 5},
    {41, 41, 1, 1},
    {46, 46, 1, 5},
    {50, 50, 1, 10},
    {53, 53, 1, 10},
    {55, 55, 1, 5},
    {56, 56, 1, 1},
    {36, 21, 2, 1},
    {37, 21, 3, 1},
    {37, 22, 2, 4},
    {42, 21, 4, 1},
    {42, 26, 2, 4},
    {38, 22, 3, 4},
    {38, 23, 2, 6},
    {43, 22, 4, 4},
    {43, 26, 3, 4},
    {43, 27, 2, 12},
    {47, 26, 4, 4},
    {47, 30, 2, 6},
    {39, 23, 3, 6},
    {39, 24, 2, 4},
    {44, 23, 4, 6},
    {44, 27, 3, 12},
    {44, 28, 2, 12},
    {48, 27, 4, 12},
    {48, 30, 3, 6},
    {48, 31, 2, 12},
    {51, 30, 4, 6},
    {51, 33, 2, 4},
    {40, 24, 3, 4},
    {40, 25, 2, 1},
    {45, 24, 4, 4},
    {45, 28, 3, 12},
    {45, 29, 2, 4},
    {49, 28, 4, 12},
    {49, 31, 3, 12},
    {49, 32, 2, 6},
    {52, 31, 4, 12},
    {52, 33, 3, 4},
    {52, 34, 2, 4},
    {54, 33, 4, 4},
    {54, 35, 2, 1},
    {41, 25, 3, 1},
    {46, 25, 4, 1},
    {46, 29, 3, 4},
    {50, 29, 4, 4},
    {50, 32, 3, 6},
    {53, 32, 4, 6},
    {53, 34, 3, 4},
    {55, 34, 4, 4},
    {55, 35, 3, 1},
    {56, 35, 4, 1},
    {36, 11, 5, 1},
    {37, 11, 6, 2},
    {37, 12, 5, 3},
    {42, 11, 8, 2},
    {42, 15, 5, 3},
    {38, 11, 7, 1},
    {38, 12, 6, 6},
    {38, 13, 5, 3},
    {43, 11, 9, 2},
    {43, 12, 8, 6},
    {43, 15, 6, 6},
    {43, 16, 5, 6},
    {47, 11, 10, 1},
    {47, 15, 8, 6},
    {47, 18, 5, 3},
    {39, 12, 7, 3},
    {39, 13, 6, 6},
    {39, 14, 5, 1},
    {44, 12, 9, 6},
    {44, 15, 7, 3},
    {44, 13, 8, 6},
    {44, 16, 6, 12},
    {44, 17, 5, 3},
    {48, 12, 10, 3},
    {48, 15, 9, 6},
    {48, 16, 8, 12},
    {48, 18, 6, 6},
    {48, 19, 5, 3},
    {51, 15, 10, 3},
    {51, 18, 8, 6},
    {51, 20, 5, 1},
    {40, 13, 7, 3},
    {40, 14, 6, 2},
    {45, 13, 9, 6},
    {45, 16, 7, 6},
    {45, 14, 8, 2},
    {45, 17, 6, 6},
    {49, 13, 10, 3},
    {49, 16, 9, 12},
    {49, 18, 7, 3},
    {49, 17, 8, 6},
    {49, 19, 6, 6},
    {52, 16, 10, 6},
    {52, 18, 9, 6},
    {52, 19, 8, 6},
    {52, 20, 6, 2},
    {54, 18, 10, 3},
    {54, 20, 8, 2},
    {41, 14, 7, 1},
    {46, 14, 9, 2},
    {46, 17, 7, 3},
    {50, 14, 10, 1},
    {50, 17, 9, 6},
    {50, 19, 7, 3},
    {53, 17, 10, 3},
    {53, 19, 9, 6},
    {53, 20, 7, 1},
    {55, 19, 10, 3},
    {55, 20, 9, 2},
    {56, 20, 10, 1},
    {21, 21, 5, 1},
    {21, 22, 6, 1},
    {21, 26, 8, 1},
    {22, 21, 6, 1},
    {22, 22, 5, 3},
    {22, 22, 7, 1},
    {22, 26, 9, 1},
    {22, 23, 6, 3},
    {22, 27, 8, 3},
    {26, 21, 8, 1},
    {26, 22, 9, 1},
    {26, 26, 5, 3},
    {26, 26, 10, 1},
    {26, 27, 6, 3},
    {26, 30, 8, 3},
    {23, 22, 6, 3},
    {23, 23, 5, 3},
    {23, 23, 7, 3},
    {23, 27, 9, 3},
    {23, 24, 6, 3},
    {23, 28, 8, 3},
    {27, 22, 8, 3},
    {27, 26, 6, 3},
    {27, 23, 9, 3},
    {27, 27, 5, 6},
    {27, 27, 7, 3},
    {27, 27, 10, 3},
    {27, 30, 9, 3},
    {27, 28, 6, 6},
    {27, 31, 8, 6},
    {30, 26, 8, 3},
    {30, 27, 9, 3},
    {30, 30, 5, 3},
    {30, 30, 10, 3},
    {30, 31, 6, 3},
    {30, 33, 8, 3},
    {24, 23, 6, 3},
    {24, 24, 5, 1},
    {24, 24, 7, 3},
    {24, 28, 9, 3},
    {24, 25, 6, 1},
    {24, 29, 8, 1},
    {28, 23, 8, 3},
    {28, 27, 6, 6},
    {28, 24, 9, 3},
    {28, 28, 5, 3},
    {28, 28, 7, 6},
    {28, 28, 10, 3},
    {28, 31, 9, 6},
    {28, 29, 6, 3},
    {28, 32, 8, 3},
    {31, 27, 8, 6},
    {31, 30, 6, 3},
    {31, 28, 9, 6},
    {31, 31, 5, 3},
    {31, 31, 7, 3},
    {31, 31, 10, 6},
    {31, 33, 9, 3},
    {31, 32, 6, 3},
    {31, 34, 8, 3},
    {33, 30, 8, 3},
    {33, 31, 9, 3},
    {33, 33, 5, 1},
    {33, 33, 10, 3},
    {33, 34, 6, 1},
    {33, 35, 8, 1},
    {25, 24, 6, 1},
    {25, 25, 7, 1},
    {25, 29, 9, 1},
    {29, 24, 8, 1},
    {29, 28, 6, 3},
    {29, 25, 9, 1},
    {29, 29, 7, 3},
    {29, 29, 10, 1},
    {29, 32, 9, 3},
    {32, 28, 8, 3},
    {32, 31, 6, 3},
    {32, 29, 9, 3},
    {32, 32, 7, 3},
    {32, 32, 10, 3},
    {32, 34, 9, 3},
    {34, 31, 8, 3},
    {34, 33, 6, 1},
    {34, 32, 9, 3},
    {34, 34, 7, 1},
    {34, 34, 10, 3},
    {34, 35, 9, 1},
    {35, 33, 8, 1},
    {35, 34, 9, 1},
    {35, 35, 10, 1},
    {21, 11, 11, 1},
    {21, 12, 12, 1},
    {21, 15, 15, 1},
    {22, 11, 12, 2},
    {22, 12, 11, 2},
    {22, 12, 13, 2},
    {22, 15, 16, 2},
    {22, 13, 12, 2},
    {22, 16, 15, 2},
    {26, 11, 15, 2},
    {26, 12, 16, 2},
    {26, 15, 11, 2},
    {26, 15, 18, 2},
    {26, 16, 12, 2},
    {26, 18, 15, 2},
    {23, 11, 13, 1},
    {23, 12, 12, 4},
    {23, 12, 14, 1},
    {23, 15, 17, 1},
    {23, 13, 11, 1},
    {23, 13, 13, 4},
    {23, 16, 16, 4},
    {23, 14, 12, 1},
    {23, 17, 15, 1},
    {27, 11, 16, 2},
    {27, 12, 15, 4},
    {27, 12, 17, 2},
    {27, 15, 12, 4},
    {27, 15, 19, 2},
    {27, 13, 16, 4},
    {27, 16, 11, 2},
    {27, 16, 13, 4},
    {27, 16, 18, 4},
    {27, 18, 16, 4},
    {27, 17, 12, 2},
    {27, 19, 15, 2},
    {30, 11, 18, 1},
    {30, 12, 19, 1},
    {30, 15, 15, 4},
    {30, 15, 20, 1},
    {30, 16, 16, 4},
    {30, 18, 11, 1},
    {30, 18, 18, 4},
    {30, 19, 12, 1},
    {30, 20, 15, 1},
    {24, 12, 13, 2},
    {24, 13, 12, 2},
    {24, 13, 14, 2},
    {24, 16, 17, 2},
    {24, 14, 13, 2},
    {24, 17, 16, 2},
    {28, 12, 16, 4},
    {28, 15, 13, 2},
    {28, 13, 15, 2},
    {28, 13, 17, 4},
    {28, 16, 12, 4},
    {28, 16, 14, 2},
    {28, 16, 19, 4},
    {28, 18, 17, 2},
    {28, 14, 16, 2},
    {28, 17, 13, 4},
    {28, 17, 18, 2},
    {28, 19, 16, 4},
    {31, 12, 18, 2},
    {31, 15, 16, 4},
    {31, 13, 19, 2},
    {31, 16, 15, 4},
    {31, 16, 17, 4},
    {31, 16, 20, 2},
    {31, 18, 12, 2},
    {31, 18, 19, 4},
    {31, 17, 16, 4},
    {31, 19, 13, 2},
    {31, 19, 18, 4},
    {31, 20, 16, 2},
    {33, 15, 18, 2},
    {33, 16, 19, 2},
    {33, 18, 15, 2},
    {33, 18, 20, 2},
    {33, 19, 16, 2},
    {33, 20, 18, 2},
    {25, 13, 13, 1},
    {25, 14, 14, 1},
    {25, 17, 17, 1},
    {29, 13, 16, 2},
    {29, 16, 13, 2},
    {29, 14, 17, 2},
    {29, 17, 14, 2},
    {29, 17, 19, 2},
    {29, 19, 17, 2},
    {32, 13, 18, 1},
    {32, 16, 16, 4},
    {32, 18, 13, 1},
    {32, 14, 19, 1},
    {32, 17, 17, 4},
    {32, 17, 20, 1},
    {32, 19, 14, 1},
    {32, 19, 19, 4},
    {32, 20, 17, 1},
    {34, 16, 18, 2},
    {34, 18, 16, 2},
    {34, 17, 19, 2},
    {34, 19, 17, 2},
    {34, 19, 20, 2},
    {34, 20, 19, 2},
    {35, 18, 18, 1},
    {35, 19, 19, 1},
    {35, 20, 20, 1},
    {57, 57, 1, 1},
    {58, 58, 1, 6},
    {64, 64, 1, 6},
    {59, 59, 1, 15},
    {65, 65, 1, 30},
    {70, 70, 1, 15},
    {60, 60, 1, 20},
    {66, 66, 1, 60},
    {71, 71, 1, 60},
    {75, 75, 1, 20},
    {61, 61, 1, 15},
    {67, 67, 1, 60},
    {72, 72, 1, 90},
    {76, 76, 1, 60},
    {79, 79, 1, 15},
    {62, 62, 1, 6},
    {68, 68, 1, 30},
    {73, 73, 1, 60},
    {77, 77, 1, 60},
    {80, 80, 1, 30},
    {82, 82, 1, 6},
    {63, 63, 1, 1},
    {69, 69, 1, 6},
    {74, 74, 1, 15},
    {78, 78, 1, 20},
    {81, 81, 1, 15},
    {83, 83, 1, 6},
    {84, 84, 1, 1},
    {57, 36, 2, 1},
    {58, 36, 3, 1},
    {58, 37, 2, 5},
    {64, 36, 4, 1},
    {64, 42, 2, 5},
    {59, 37, 3, 5},
    {59, 38, 2, 10},
    {65, 37, 4, 5},
    {65, 42, 3, 5},
    {65, 43, 2, 20},
    {70, 42, 4, 5},
    {70, 47, 2, 10},
    {60, 38, 3, 10},
    {60, 39, 2, 10},
    {66, 38, 4, 10},
    {66, 43, 3, 20},
    {66, 44, 2, 30},
    {71, 43, 4, 20},
    {71, 47, 3, 10},
    {71, 48, 2, 30},
    {75, 47, 4, 10},
    {75, 51, 2, 10},
    {61, 39, 3, 10},
    {61, 40, 2, 5},
    {67, 39, 4, 10},
    {67, 44, 3, 30},
    {67, 45, 2, 20},
    {72, 44, 4, 30},
    {72, 48, 3, 30},
    {72, 49, 2, 30},
    {76, 48, 4, 30},
    {76, 51, 3, 10},
    {76, 52, 2, 20},
    {79, 51, 4, 10},
    {79, 54, 2, 5},
    {62, 40, 3, 5},
    {62, 41, 2, 1},
    {68, 40, 4, 5},
    {68, 45, 3, 20},
    {68, 46, 2, 5},
    {73, 45, 4, 20},
    {73, 49, 3, 30},
    {73, 50, 2, 10},
    {77, 49, 4, 30},
    {77, 52, 3, 20},
    {77, 53, 2, 10},
    {80, 52, 4, 20},
    {80, 54, 3, 5},
    {80, 55, 2, 5},
    {82, 54, 4, 5},
    {82, 56, 2, 1},
    {63, 41, 3, 1},
    {69, 41, 4, 1},
    {69, 46, 3, 5},
    {74, 46, 4, 5},
    {74, 50, 3, 10},
    {78, 50, 4, 10},
    {78, 53, 3, 10},
    {81, 53, 4, 10},
    {81, 55, 3, 5},
    {83, 55, 4, 5},
    {83, 56, 3, 1},
    {84, 56, 4, 1},
    {57, 21, 5, 1},
    {58, 21, 6, 2},
    {58, 22, 5, 4},
    {64, 21, 8, 2},
    {64, 26, 5, 4},
    {59, 21, 7, 1},
    {59, 22, 6, 8},
    {59, 23, 5, 6},
    {65, 21, 9, 2},
    {65, 22, 8, 8},
    {65, 26, 6, 8},
    {65, 27, 5, 12},
    {70, 21, 10, 1},
    {70, 26, 8, 8},
    {70, 30, 5, 6},
    {60, 22, 7, 4},
    {60, 23, 6, 12},
    {60, 24, 5, 4},
    {66, 22, 9, 8},
    {66, 26, 7, 4},
    {66, 23, 8, 12},
    {66, 27, 6, 24},
    {66, 28, 5, 12},
    {71, 22, 10, 4},
    {71, 26, 9, 8},
    {71, 27, 8, 24},
    {71, 30, 6, 12},
    {71, 31, 5, 12},
    {75, 26, 10, 4},
    {75, 30, 8, 12},
    {75, 33, 5, 4},
    {61, 23, 7, 6},
    {61, 24, 6, 8},
    {61, 25, 5, 1},
    {67, 23, 9, 12},
    {67, 27, 7, 12},
    {67, 24, 8, 8},
    {67, 28, 6, 24},
    {67, 29, 5, 4},
    {72, 23, 10, 6},
    {72, 27, 9, 24},
    {72, 30, 7, 6},
    {72, 28, 8, 24},
    {72, 31, 6, 24},
    {72, 32, 5, 6},
    {76, 27, 10, 12},
    {76, 30, 9, 12},
    {76, 31, 8, 24},
    {76, 33, 6, 8},
    {76, 34, 5, 4},
    {79, 30, 10, 6},
    {79, 33, 8, 8},
    {79, 35, 5, 1},
    {62, 24, 7, 4},
    {62, 25, 6, 2},
    {68, 24, 9, 8},
    {68, 28, 7, 12},
    {68, 25, 8, 2},
    {68, 29, 6, 8},
    {73, 24, 10, 4},
    {73, 28, 9, 24},
    {73, 31, 7, 12},
    {73, 29, 8, 8},
    {73, 32, 6, 12},
    {77, 28, 10, 12},
    {77, 31, 9, 24},
    {77, 33, 7, 4},
    {77, 32, 8, 12},
    {77, 34, 6, 8},
    {80, 31, 10, 12},
    {80, 33, 9, 8},
    {80, 34, 8, 8},
    {80, 35, 6, 2},
    {82, 33, 10, 4},
    {82, 35, 8, 2},
    {63, 25, 7, 1},
    {69, 25, 9, 2},
    {69, 29, 7, 4},
    {74, 25, 10, 1},
    {74, 29, 9, 8},
    {74, 32, 7, 6},
    {78, 29, 10, 4},
    {78, 32, 9, 12},
    {78, 34, 7, 4},
    {81, 32, 10, 6},
    {81, 34, 9, 8},
    {81, 35, 7, 1},
    {83, 34, 10, 4},
    {83, 35, 9, 2},
    {84, 35, 10, 1},
    {36, 36, 5, 1},
    {36, 37, 6, 1},
    {36, 42, 8, 1},
    {37, 36, 6, 1},
    {37, 37, 5, 4},
    {37, 37, 7, 1},
    {37, 42, 9, 1},
    {37, 38, 6, 4},
    {37, 43, 8, 4},
    {42, 36, 8, 1},
    {42, 37, 9, 1},
    {42, 42, 5, 4},
    {42, 42, 10, 1},
    {42, 43, 6, 4},
    {42, 47, 8, 4},
    {38, 37, 6, 4},
    {38, 38, 5, 6},
    {38, 38, 7, 4},
    {38, 43, 9, 4},
    {38, 39, 6, 6},
    {38, 44, 8, 6},
    {43, 37, 8, 4},
    {43, 42, 6, 4},
    {43, 38, 9, 4},
    {43, 43, 5, 12},
    {43, 43, 7, 4},
    {43, 43, 10, 4},
    {43, 47, 9, 4},
    {43, 44, 6, 12},
    {43, 48, 8, 12},
    {47, 42, 8, 4},
    {47, 43, 9, 4},
    {47, 47, 5, 6},
    {47, 47, 10, 4},
    {47, 48, 6, 6},
    {47, 51, 8, 6},
    {39, 38, 6, 6},
    {39, 39, 5, 4},
    {39, 39, 7, 6},
    {39, 44, 9, 6},
    {39, 40, 6, 4},
    {39, 45, 8, 4},
    {44, 38, 8, 6},
    {44, 43, 6, 12},
    {44, 39, 9, 6},
    {44, 44, 5, 12},
    {44, 44, 7, 12},
    {44, 44, 10, 6},
    {44, 48, 9, 12},
    {44, 45, 6, 12},
    {44, 49, 8, 12},
    {48, 43, 8, 12},
    {48, 47, 6, 6},
    {48, 44, 9, 12},
    {48, 48, 5, 12},
    {48, 48, 7, 6},
    {48, 48, 10, 12},
    {48, 51, 9, 6},
    {48, 49, 6, 12},
    {48, 52, 8, 12},
    {51, 47, 8, 6},
    {51, 48, 9, 6},
    {51, 51, 5, 4},
    {51, 51, 10, 6},
    {51, 52, 6, 4},
    {51, 54, 8, 4},
    {40, 39, 6, 4},
    {40, 40, 5, 1},
    {40, 40, 7, 4},
    {40, 45, 9, 4},
    {40, 41, 6, 1},
    {40, 46, 8, 1},
    {45, 39, 8, 4},
    {45, 44, 6, 12},
    {45, 40, 9, 4},
    {45, 45, 5, 4},
    {45, 45, 7, 12},
    {45, 45, 10, 4},
    {45, 49, 9, 12},
    {45, 46, 6, 4},
    {45, 50, 8, 4},
    {49, 44, 8, 12},
    {49, 48, 6, 12},
    {49, 45, 9, 12},
    {49, 49, 5, 6},
    {49, 49, 7, 12},
    {49, 49, 10, 12},
    {49, 52, 9, 12},
    {49, 50, 6, 6},
    {49, 53, 8, 6},
    {52, 48, 8, 12},
    {52, 51, 6, 4},
    {52, 49, 9, 12},
    {52, 52, 5, 4},
    {52, 52, 7, 4},
    {52, 52, 10, 12},
    {52, 54, 9, 4},
    {52, 53, 6, 4},
    {52, 55, 8, 4},
    {54, 51, 8, 4},
    {54, 52, 9, 4},
    {54, 54, 5, 1},
    {54, 54, 10, 4},
    {54, 55, 6, 1},
    {54, 56, 8, 1},
    {41, 40, 6, 1},
    {41, 41, 7, 1},
    {41, 46, 9, 1},
    {46, 40, 8, 1},
    {46, 45, 6, 4},
    {46, 41, 9, 1},
    {46, 46, 7, 4},
    {46, 46, 10, 1},
    {46, 50, 9, 4},
    {50, 45, 8, 4},
    {50, 49, 6, 6},
    {50, 46, 9, 4},
    {50, 50, 7, 6},
    {50, 50, 10, 4},
    {50, 53, 9, 6},
    {53, 49, 8, 6},
    {53, 52, 6, 4},
    {53, 50, 9, 6},
    {53, 53, 7, 4},
    {53, 53, 10, 6},
    {53, 55, 9, 4},
    {55, 52, 8, 4},
    {55, 54, 6, 1},
    {55, 53, 9, 4},
    {55, 55, 7, 1},
    {55, 55, 10, 4},
    {55, 56, 9, 1},
    {56, 54, 8, 1},
    {56, 55, 9, 1},
    {56, 56, 10, 1},
    {57, 11, 11, 1},
    {58, 11, 12, 3},
    {58, 12, 11, 3},
    {64, 11, 15, 3},
    {64, 15, 11, 3},
    {59, 11, 13, 3},
    {59, 12, 12, 9},
    {59, 13, 11, 3},
    {65, 11, 16, 6},
    {65, 12, 15, 9},
    {65, 15, 12, 9},
    {65, 16, 11, 6},
    {70, 11, 18, 3},
    {70, 15, 15, 9},
    {70, 18, 11, 3},
    {60, 11, 14, 1},
    {60, 12, 13, 9},
    {60, 13, 12, 9},
    {60, 14, 11, 1},
    {66, 11, 17, 3},
    {66, 12, 16, 18},
    {66, 15, 13, 9},
    {66, 13, 15, 9},
    {66, 16, 12, 18},
    {66, 17, 11, 3},
    {71, 11, 19, 3},
    {71, 12, 18, 9},
    {71, 15, 16, 18},
    {71, 16, 15, 18},
    {71, 18, 12, 9},
    {71, 19, 11, 3},
    {75, 11, 20, 1},
    {75, 15, 18, 9},
    {75, 18, 15, 9},
    {75, 20, 11, 1},
    {61, 12, 14, 3},
    {61, 13, 13, 9},
    {61, 14, 12, 3},
    {67, 12, 17, 9},
    {67, 15, 14, 3},
    {67, 13, 16, 18},
    {67, 16, 13, 18},
    {67, 14, 15, 3},
    {67, 17, 12, 9},
    {72, 12, 19, 9},
    {72, 15, 17, 9},
    {72, 13, 18, 9},
    {72, 16, 16, 36},
    {72, 18, 13, 9},
    {72, 17, 15, 9},
    {72, 19, 12, 9},
    {76, 12, 20, 3},
    {76, 15, 19, 9},
    {76, 16, 18, 18},
    {76, 18, 16, 18},
    {76, 19, 15, 9},
    {76, 20, 12, 3},
    {79, 15, 20, 3},
    {79, 18, 18, 9},
    {79, 20, 15, 3},
    {62, 13, 14, 3},
    {62, 14, 13, 3},
    {68, 13, 17, 9},
    {68, 16, 14, 6},
    {68, 14, 16, 6},
    {68, 17, 13, 9},
    {73, 13, 19, 9},
    {73, 16, 17, 18},
    {73, 18, 14, 3},
    {73, 14, 18, 3},
    {73, 17, 16, 18},
    {73, 19, 13, 9},
    {77, 13, 20, 3},
    {77, 16, 19, 18},
    {77, 18, 17, 9},
    {77, 17, 18, 9},
    {77, 19, 16, 18},
    {77, 20, 13, 3},
    {80, 16, 20, 6},
    {80, 18, 19, 9},
    {80, 19, 18, 9},
    {80, 20, 16, 6},
    {82, 18, 20, 3},
    {82, 20, 18, 3},
    {63, 14, 14, 1},
    {69, 14, 17, 3},
    {69, 17, 14, 3},
    {74, 14, 19, 3},
    {74, 17, 17, 9},
    {74, 19, 14, 3},
    {78, 14, 20, 1},
    {78, 17, 19, 9},
    {78, 19, 17, 9},
    {78, 20, 14, 1},
    {81, 17, 20, 3},
    {81, 19, 19, 9},
    {81, 20, 17, 3},
    {83, 19, 20, 3},
    {83, 20, 19, 3},
    {84, 20, 20, 1},
    {36, 21, 11, 1},
    {36, 22, 12, 1},
    {36, 26, 15, 1},
    {37, 21, 12, 2},
    {37, 22, 11, 3},
    {37, 22, 13, 2},
    {37, 26, 16, 2},
    {37, 23, 12, 3},
    {37, 27, 15, 3},
    {42, 21, 15, 2},
    {42, 22, 16, 2},
    {42, 26, 11, 3},
    {42, 26, 18, 2},
    {42, 27, 12, 3},
    {42, 30, 15, 3},
    {38, 21, 13, 1},
    {38, 22, 12, 6},
    {38, 22, 14, 1},
    {38, 26, 17, 1},
    {38, 23, 11, 3},
    {38, 23, 13, 6},
    {38, 27, 16, 6},
    {38, 24, 12, 3},
    {38, 28, 15, 3},
    {43, 21, 16, 2},
    {43, 22, 15, 6},
    {43, 22, 17, 2},
    {43, 26, 12, 6},
    {43, 26, 19, 2},
    {43, 23, 16, 6},
    {43, 27, 11, 6},
    {43, 27, 13, 6},
    {43, 27, 18, 6},
    {43, 30, 16, 6},
    {43, 28, 12, 6},
    {43, 31, 15, 6},
    {47, 21, 18, 1},
    {47, 22, 19, 1},
    {47, 26, 15, 6},
    {47, 26, 20, 1},
    {47, 27, 16, 6},
    {47, 30, 11, 3},
    {47, 30, 18, 6},
    {47, 31, 12, 3},
    {47, 33, 15, 3},
    {39, 22, 13, 3},
    {39, 23, 12, 6},
    {39, 23, 14, 3},
    {39, 27, 17, 3},
    {39, 24, 11, 1},
    {39, 24, 13, 6},
    {39, 28, 16, 6},
    {39, 25, 12, 1},
    {39, 29, 15, 1},
    {44, 22, 16, 6},
    {44, 26, 13, 3},
    {44, 23, 15, 6},
    {44, 23, 17, 6},
    {44, 27, 12, 12},
    {44, 27, 14, 3},
    {44, 27, 19, 6},
    {44, 30, 17, 3},
    {44, 24, 16, 6},
    {44, 28, 11, 3},
    {44, 28, 13, 12},
    {44, 28, 18, 6},
    {44, 31, 16, 12},
    {44, 29, 12, 3},
    {44, 32, 15, 3},
    {48, 22, 18, 3},
    {48, 26, 16, 6},
    {48, 23, 19, 3},
    {48, 27, 15, 12},
    {48, 27, 17, 6},
    {48, 27, 20, 3},
    {48, 30, 12, 6},
    {48, 30, 19, 6},
    {48, 28, 16, 12},
    {48, 31, 11, 3},
    {48, 31, 13, 6},
    {48, 31, 18, 12},
    {48, 33, 16, 6},
    {48, 32, 12, 3},
    {48, 34, 15, 3},
    {51, 26, 18, 3},
    {51, 27, 19, 3},
    {51, 30, 15, 6},
    {51, 30, 20, 3},
    {51, 31, 16, 6},
    {51, 33, 11, 1},
    {51, 33, 18, 6},
    {51, 34, 12, 1},
    {51, 35, 15, 1},
    {40, 23, 13, 3},
    {40, 24, 12, 2},
    {40, 24, 14, 3},
    {40, 28, 17, 3},
    {40, 25, 13, 2},
    {40, 29, 16, 2},
    {45, 23, 16, 6},
    {45, 27, 13, 6},
    {45, 24, 15, 2},
    {45, 24, 17, 6},
    {45, 28, 12, 6},
    {45, 28, 14, 6},
    {45, 28, 19, 6},
    {45, 31, 17, 6},
    {45, 25, 16, 2},
    {45, 29, 13, 6},
    {45, 29, 18, 2},
    {45, 32, 16, 6},
    {49, 23, 18, 3},
    {49, 27, 16, 12},
    {49, 30, 13, 3},
    {49, 24, 19, 3},
    {49, 28, 15, 6},
    {49, 28, 17, 12},
    {49, 28, 20, 3},
    {49, 31, 12, 6},
    {49, 31, 14, 3},
    {49, 31, 19, 12},
    {49, 33, 17, 3},
    {49, 29, 16, 6},
    {49, 32, 13, 6},
    {49, 32, 18, 6},
    {49, 34, 16, 6},
    {52, 27, 18, 6},
    {52, 30, 16, 6},
    {52, 28, 19, 6},
    {52, 31, 15, 6},
    {52, 31, 17, 6},
    {52, 31, 20, 6},
    {52, 33, 12, 2},
    {52, 33, 19, 6},
    {52, 32, 16, 6},
    {52, 34, 13, 2},
    {52, 34, 18, 6},
    {52, 35, 16, 2},
    {54, 30, 18, 3},
    {54, 31, 19, 3},
    {54, 33, 15, 2},
    {54, 33, 20, 3},
    {54, 34, 16, 2},
    {54, 35, 18, 2},
    {41, 24, 13, 1},
    {41, 25, 14, 1},
    {41, 29, 17, 1},
    {46, 24, 16, 2},
    {46, 28, 13, 3},
    {46, 25, 17, 2},
    {46, 29, 14, 3},
    {46, 29, 19, 2},
    {46, 32, 17, 3},
    {50, 24, 18, 1},
    {50, 28, 16, 6},
    {50, 31, 13, 3},
    {50, 25, 19, 1},
    {50, 29, 17, 6},
    {50, 29, 20, 1},
    {50, 32, 14, 3},
    {50, 32, 19, 6},
    {50, 34, 17, 3},
    {53, 28, 18, 3},
    {53, 31, 16, 6},
    {53, 33, 13, 1},
    {53, 29, 19, 3},
    {53, 32, 17, 6},
    {53, 32, 20, 3},
    {53, 34, 14, 1},
    {53, 34, 19, 6},
    {53, 35, 17, 1},
    {55, 31, 18, 3},
    {55, 33, 16, 2},
    {55, 32, 19, 3},
    {55, 34, 17, 2},
    {55, 34, 20, 3},
    {55, 35, 19, 2},
    {56, 33, 18, 1},
    {56, 34, 19, 1},
    {56, 35, 20, 1},
    {21, 21, 21, 1},
    {21, 22, 22, 2},
    {21, 26, 26, 2},
    {21, 23, 23, 1},
    {21, 27, 27, 2},
    {21, 30, 30, 1},
    {22, 21, 22, 2},
    {22, 22, 21, 2},
    {22, 22, 23, 4},
    {22, 26, 27, 4},
    {22, 23, 22, 4},
    {22, 23, 24, 2},
    {22, 27, 26, 4},
    {22, 27, 28, 4},
    {22, 30, 31, 2},
    {22, 24, 23, 2},
    {22, 28, 27, 4},
    {22, 31, 30, 2},
    {26, 21, 26, 2},
    {26, 22, 27, 4},
    {26, 26, 21, 2},
    {26, 26, 30, 4},
    {26, 23, 28, 2},
    {26, 27, 22, 4},
    {26, 27, 31, 4},
    {26, 30, 26, 4},
    {26, 30, 33, 2},
    {26, 28, 23, 2},
    {26, 31, 27, 4},
    {26, 33, 30, 2},
    {23, 21, 23, 1},
    {23, 22, 22, 4},
    {23, 22, 24, 2},
    {23, 26, 28, 2},
    {23, 23, 21, 1},
    {23, 23, 23, 8},
    {23, 23, 25, 1},
    {23, 27, 27, 8},
    {23, 27, 29, 2},
    {23, 30, 32, 1},
    {23, 24, 22, 2},
    {23, 24, 24, 4},
    {23, 28, 26, 2},
    {23, 28, 28, 8},
    {23, 31, 31, 4},
    {23, 25, 23, 1},
    {23, 29, 27, 2},
    {23, 32, 30, 1},
    {27, 21, 27, 2},
    {27, 22, 26, 4},
    {27, 22, 28, 4},
    {27, 26, 22, 4},
    {27, 26, 31, 4},
    {27, 23, 27, 8},
    {27, 23, 29, 2},
    {27, 27, 21, 2},
    {27, 27, 23, 8},
    {27, 27, 30, 8},
    {27, 27, 32, 4},
    {27, 30, 27, 8},
    {27, 30, 34, 2},
    {27, 24, 28, 4},
    {27, 28, 22, 4},
    {27, 28, 24, 4},
    {27, 28, 31, 8},
    {27, 31, 26, 4},
    {27, 31, 28, 8},
    {27, 31, 33, 4},
    {27, 33, 31, 4},
    {27, 29, 23, 2},
    {27, 32, 27, 4},
    {27, 34, 30, 2},
    {30, 21, 30, 1},
    {30, 22, 31, 2},
    {30, 26, 26, 4},
    {30, 26, 33, 2},
    {30, 23, 32, 1},
    {30, 27, 27, 8},
    {30, 27, 34, 2},
    {30, 30, 21, 1},
    {30, 30, 30, 8},
    {30, 30, 35, 1},
    {30, 28, 28, 4},
    {30, 31, 22, 2},
    {30, 31, 31, 8},
    {30, 33, 26, 2},
    {30, 33, 33, 4},
    {30, 32, 23, 1},
    {30, 34, 27, 2},
    {30, 35, 30, 1},
    {24, 22, 23, 2},
    {24, 23, 22, 2},
    {24, 23, 24, 4},
    {24, 27, 28, 4},
    {24, 24, 23, 4},
    {24, 24, 25, 2},
    {24, 28, 27, 4},
    {24, 28, 29, 4},
    {24, 31, 32, 2},
    {24, 25, 24, 2},
    {24, 29, 28, 4},
    {24, 32, 31, 2},
    {28, 22, 27, 4},
    {28, 26, 23, 2},
    {28, 23, 26, 2},
    {28, 23, 28, 8},
    {28, 27, 22, 4},
    {28, 27, 24, 4},
    {28, 27, 31, 8},
    {28, 30, 28, 4},
    {28, 24, 27, 4},
    {28, 24, 29, 4},
    {28, 28, 23, 8},
    {28, 28, 30, 4},
    {28, 28, 25, 2},
    {28, 28, 32, 8},
    {28, 31, 27, 8},
    {28, 31, 29, 4},
    {28, 31, 34, 4},
    {28, 33, 32, 2},
    {28, 25, 28, 2},
    {28, 29, 24, 4},
    {28, 29, 31, 4},
    {28, 32, 28, 8},
    {28, 32, 33, 2},
    {28, 34, 31, 4},
    {31, 22, 30, 2},
    {31, 26, 27, 4},
    {31, 23, 31, 4},
    {31, 27, 26, 4},
    {31, 27, 28, 8},
    {31, 27, 33, 4},
    {31, 30, 22, 2},
    {31, 30, 31, 8},
    {31, 24, 32, 2},
    {31, 28, 27, 8},
    {31, 28, 29, 4},
    {31, 28, 34, 4},
    {31, 31, 23, 4},
    {31, 31, 30, 8},
    {31, 31, 32, 8},
    {31, 31, 35, 2},
    {31, 33, 27, 4},
    {31, 33, 34, 4},
    {31, 29, 28, 4},
    {31, 32, 24, 2},
    {31, 32, 31, 8},
    {31, 34, 28, 4},
    {31, 34, 33, 4},
    {31, 35, 31, 2},
    {33, 26, 30, 2},
    {33, 27, 31, 4},
    {33, 30, 26, 2},
    {33, 30, 33, 4},
    {33, 28, 32, 2},
    {33, 31, 27, 4},
    {33, 31, 34, 4},
    {33, 33, 30, 4},
    {33, 33, 35, 2},
    {33, 32, 28, 2},
    {33, 34, 31, 4},
    {33, 35, 33, 2},
    {25, 23, 23, 1},
    {25, 24, 24, 2},
    {25, 28, 28, 2},
    {25, 25, 25, 1},
    {25, 29, 29, 2},
    {25, 32, 32, 1},
    {29, 23, 27, 2},
    {29, 27, 23, 2},
    {29, 24, 28, 4},
    {29, 28, 24, 4},
    {29, 28, 31, 4},
    {29, 31, 28, 4},
    {29, 25, 29, 2},
    {29, 29, 25, 2},
    {29, 29, 32, 4},
    {29, 32, 29, 4},
    {29, 32, 34, 2},
    {29, 34, 32, 2},
    {32, 23, 30, 1},
    {32, 27, 27, 4},
    {32, 30, 23, 1},
    {32, 24, 31, 2},
    {32, 28, 28, 8},
    {32, 28, 33, 2},
    {32, 31, 24, 2},
    {32, 31, 31, 8},
    {32, 33, 28, 2},
    {32, 25, 32, 1},
    {32, 29, 29, 4},
    {32, 29, 34, 2},
    {32, 32, 25, 1},
    {32, 32, 32, 8},
    {32, 32, 35, 1},
    {32, 34, 29, 2},
    {32, 34, 34, 4},
    {32, 35, 32, 1},
    {34, 27, 30, 2},
    {34, 30, 27, 2},
    {34, 28, 31, 4},
    {34, 31, 28, 4},
    {34, 31, 33, 4},
    {34, 33, 31, 4},
    {34, 29, 32, 2},
    {34, 32, 29, 2},
    {34, 32, 34, 4},
    {34, 34, 32, 4},
    {34, 34, 35, 2},
    {34, 35, 34, 2},
    {35, 30, 30, 1},
    {35, 31, 31, 2},
    {35, 33, 33, 2},
    {35, 32, 32, 1},
    {35, 34, 34, 2},
    {35, 35, 35, 1}
  };

  int nb4 = nb[Pa];
  for (int i = 0; i<= nb4; i++)
    ns4[i] = ns[i];

  int nmax = ns4[nb4];
  for (int i=0; i<nmax; i++) {
    pb4[i]        = poly[i][0]-1;
    pb4[i+nmax]   = poly[i][1]-1;
    pb4[i+2*nmax] = poly[i][2]-1;
    pc4[i]        = poly[i][3];
  }
}
