collision.cse.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2021 Adrian Kummerlaender
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
*/
 
#ifndef DYNAMICS_COLLISION_CSE_H
#define DYNAMICS_COLLISION_CSE_H
 
 
#ifndef DISABLE_CSE
 
#include "equilibrium.h"
#include "latticeDescriptors.h"
 
namespace olb {
 
namespace collision {
 
template <typename... FIELDS>
struct BGK::type<descriptors::D2Q5<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x7 = parameters.template get<olb::descriptors::OMEGA>();
auto x5 = x7 + V{-1};
auto x6 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4];
auto x8 = x6 + V{1};
auto x9 = x6 + V{1};
auto x10 = V{1} / ((x9)*(x9));
auto x11 = V{1.5}*x10;
auto x12 = cell[2] - cell[4];
auto x13 = -x12;
auto x14 = x13*x13;
auto x15 = cell[1] - cell[3];
auto x16 = -x15;
auto x17 = x11*(x16*x16) + V{-1};
auto x18 = V{0.166666666666667}*x7;
auto x19 = V{1} / (x9);
auto x20 = x19*(V{3}*cell[1] - V{3}*cell[3]);
auto x21 = V{3}*x10;
auto x22 = x15*x15;
auto x23 = x12*x12;
auto x24 = x11*x23;
auto x25 = V{3}*cell[2] - V{3}*cell[4];
cell[0] = -x5*cell[0] - V{0.333333333333333}*x7*(x8*(x11*x14 + x17) + V{1});
cell[1] = x18*(x8*(x20 + x21*x22 - x24 + V{1}) + V{-1}) - x5*cell[1];
cell[2] = -x18*(x8*(-x14*x21 + x17 - x19*x25) + V{1}) - x5*cell[2];
cell[3] = x18*(x8*(V{3}*x10*x22 - x20 - x24 + V{1}) + V{-1}) - x5*cell[3];
cell[4] = -x18*(x8*(x11*x22 + x19*x25 - x21*x23 + V{-1}) + V{1}) - x5*cell[4];
return { x9, V{1}*x10*(x22 + x23) };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D2Q5<FIELDS...>,momenta::BulkTuple,equilibria::Incompressible> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x7 = parameters.template get<olb::descriptors::OMEGA>();
auto x5 = V{0.333333333333333}*cell[1];
auto x6 = V{0.333333333333333}*cell[2];
auto x8 = V{0.333333333333333}*cell[3];
auto x9 = V{0.333333333333333}*cell[4];
auto x10 = cell[1] - cell[3];
auto x11 = x10*x10;
auto x12 = V{0.5}*x11;
auto x13 = cell[2] - cell[4];
auto x14 = x13*x13;
auto x15 = V{0.5}*x14;
auto x16 = x7 + V{-1};
auto x17 = V{0.166666666666667}*cell[0];
auto x18 = x12 - V{0.25}*x14 + x17 + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[4];
auto x19 = -V{0.25}*x11 + x15 + x17 + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[3];
auto x20 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + V{1};
cell[0] = -x16*cell[0] + x7*(-x12 - x15 + x5 + x6 + x8 + x9 + V{0.333333333333333}*cell[0]);
cell[1] = -x16*cell[1] + x7*(x18 - x8 + V{0.666666666666667}*cell[1]);
cell[2] = -x16*cell[2] + x7*(x19 - x9 + V{0.666666666666667}*cell[2]);
cell[3] = -x16*cell[3] + x7*(x18 - x5 + V{0.666666666666667}*cell[3]);
cell[4] = -x16*cell[4] + x7*(x19 - x6 + V{0.666666666666667}*cell[4]);
return { x20, V{1}*(x11 + x14)/((x20)*(x20)) };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::descriptors::OMEGA>();
auto x9 = x11 + V{-1};
auto x10 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8];
auto x12 = x10 + V{1};
auto x13 = x10 + V{1};
auto x14 = V{1} / ((x13)*(x13));
auto x15 = V{1.5}*x14;
auto x16 = cell[1] - cell[5];
auto x17 = -cell[4] + cell[8];
auto x18 = x16 + x17 - cell[3] + cell[7];
auto x19 = x18*x18;
auto x20 = x15*x19;
auto x21 = cell[2] - cell[6];
auto x22 = x16 + x21 + cell[3] - cell[7];
auto x23 = -x22;
auto x24 = x15*(x23*x23) + V{-1};
auto x25 = x20 + x24;
auto x26 = V{0.0277777777777778}*x11;
auto x27 = V{4.5}*x14;
auto x28 = x17 + x21 + V{2}*cell[1] - V{2}*cell[5];
auto x29 = x27*(x28*x28);
auto x30 = V{1} / (x13);
auto x31 = V{3}*cell[3];
auto x32 = V{3}*cell[7];
auto x33 = V{3}*cell[1] - V{3}*cell[5];
auto x34 = x31 - x32 + x33 + V{3}*cell[2] - V{3}*cell[6];
auto x35 = x30*x34;
auto x36 = -x20 + x35 + V{1};
auto x37 = -x31 + x32 + x33 - V{3}*cell[4] + V{3}*cell[8];
auto x38 = x30*x37;
auto x39 = x22*x22;
auto x40 = x15*x39;
auto x41 = x38 - x40;
auto x42 = V{0.111111111111111}*x11;
auto x43 = V{3}*x14;
auto x44 = x21 + V{2}*cell[3] + cell[4] - V{2}*cell[7] - cell[8];
auto x45 = -x44;
auto x46 = x19*x43;
auto x47 = x20 + x35 + V{-1};
auto x48 = x40 + x47;
cell[0] = -V{0.444444444444444}*x11*(x12*x25 + V{1}) - x9*cell[0];
cell[1] = x26*(x12*(x29 + x36 + x41) + V{-1}) - x9*cell[1];
cell[2] = x42*(x12*(x36 + x39*x43) + V{-1}) - x9*cell[2];
cell[3] = -x26*(x12*(x25 - x27*x45*x45 - x30*x34 + x38) + V{1}) - x9*cell[3];
cell[4] = -x42*(x12*(x24 + x38 - x46) + V{1}) - x9*cell[4];
cell[5] = -x26*(x12*(-x29 + x38 + x48) + V{1}) - x9*cell[5];
cell[6] = x42*(x12*(V{3}*x14*x39 - x47) + V{-1}) - x9*cell[6];
cell[7] = x26*(-x12*(-V{4.5}*x14*x44*x44 - x30*x37 + x48) + V{-1}) - x9*cell[7];
cell[8] = x42*(x12*(x41 + x46 + V{1}) + V{-1}) - x9*cell[8];
return { x13, V{1}*x14*(x19 + x39) };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::Incompressible> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::descriptors::OMEGA>();
auto x9 = V{0.444444444444444}*cell[8];
auto x10 = cell[1] - cell[5];
auto x12 = cell[7] + cell[8];
auto x13 = x10 + x12 - cell[3] - cell[4];
auto x14 = x13*x13;
auto x15 = cell[2] + cell[3];
auto x16 = x10 + x15 - cell[6] - cell[7];
auto x17 = x16*x16;
auto x18 = V{0.444444444444444}*cell[1];
auto x19 = V{0.444444444444444}*cell[3];
auto x20 = x18 + x19 + V{0.444444444444444}*cell[2];
auto x21 = V{0.444444444444444}*cell[5];
auto x22 = x21 + V{0.444444444444444}*cell[4];
auto x23 = V{0.444444444444444}*cell[7];
auto x24 = x23 + V{0.444444444444444}*cell[6];
auto x25 = x11 + V{-1};
auto x26 = V{0.111111111111111}*cell[2];
auto x27 = V{0.0277777777777778}*cell[0];
auto x28 = -V{0.0416666666666667}*x14;
auto x29 = -V{0.0416666666666667}*x17;
auto x30 = x26 + x27 + x28 + x29 - V{0.0555555555555556}*cell[6];
auto x31 = V{0.111111111111111}*cell[8];
auto x32 = x31 - V{0.0555555555555556}*cell[4];
auto x33 = V{1}*cell[8];
auto x34 = V{1}*cell[4];
auto x35 = V{1}*cell[2] - V{1}*cell[6];
auto x36 = V{4.5}*cell[8];
auto x37 = V{4.5}*cell[4];
auto x38 = V{4.5}*cell[2] - V{4.5}*cell[6];
auto x39 = V{0.0277777777777778}*(x33 - x34 + x35 + V{2}*cell[1] - V{2}*cell[5])*(x36 - x37 + x38 + V{9}*cell[1] - V{9}*cell[5]) + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[7];
auto x40 = -V{0.222222222222222}*cell[5];
auto x41 = V{0.111111111111111}*cell[0];
auto x42 = x41 - V{0.222222222222222}*cell[7];
auto x43 = V{0.111111111111111}*cell[4];
auto x44 = -V{0.166666666666667}*x14 + V{0.333333333333333}*x17 + x31 + x43;
auto x45 = x43 - V{0.0555555555555556}*cell[8];
auto x46 = V{0.0277777777777778}*(-x33 + x34 + x35 + V{2}*cell[3] - V{2}*cell[7])*(-x36 + x37 + x38 + V{9}*cell[3] - V{9}*cell[7]) + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[5];
auto x47 = -V{0.222222222222222}*cell[1];
auto x48 = V{0.111111111111111}*cell[6];
auto x49 = V{0.333333333333333}*x14 - V{0.166666666666667}*x17 + x26 + x48;
auto x50 = x27 + x28 + x29 + x48 - V{0.0555555555555556}*cell[2];
auto x51 = x41 - V{0.222222222222222}*cell[3];
auto x52 = x12 + x15 + cell[0] + cell[1] + cell[4] + cell[5] + cell[6] + V{1};
auto x0 = x11*(-V{0.666666666666667}*x14 - V{0.666666666666667}*x17 + x20 + x22 + x24 + x9 + V{0.444444444444444}*cell[0]) - x25*cell[0];
auto x1 = x11*(x30 + x32 + x39 + V{0.194444444444444}*cell[1] - V{0.138888888888889}*cell[5]) - x25*cell[1];
auto x2 = x11*(x20 + x40 + x42 + x44 - V{0.222222222222222}*cell[6]) - x25*cell[2];
auto x3 = x11*(x30 + x45 + x46 + V{0.194444444444444}*cell[3] - V{0.138888888888889}*cell[7]) - x25*cell[3];
auto x4 = x11*(x19 + x22 + x42 + x47 + x49 - V{0.222222222222222}*cell[8]) - x25*cell[4];
auto x5 = x11*(x39 + x45 + x50 - V{0.138888888888889}*cell[1] + V{0.194444444444444}*cell[5]) - x25*cell[5];
auto x6 = x11*(x21 + x24 + x44 + x47 + x51 - V{0.222222222222222}*cell[2]) - x25*cell[6];
auto x7 = x11*(x32 + x46 + x50 - V{0.138888888888889}*cell[3] + V{0.194444444444444}*cell[7]) - x25*cell[7];
auto x8 = x11*(x18 + x23 + x40 + x49 + x51 + x9 - V{0.222222222222222}*cell[4]) - x25*cell[8];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
return { x52, V{1}*(x14 + x17)/((x52)*(x52)) };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q7<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x10 = parameters.template get<olb::descriptors::OMEGA>();
auto x7 = x10 + V{-1};
auto x8 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6];
auto x9 = x8 + V{1};
auto x11 = x8 + V{1};
auto x12 = V{1} / ((x11)*(x11));
auto x13 = V{2}*x12;
auto x14 = cell[1] - cell[4];
auto x15 = -x14;
auto x16 = x15*x15;
auto x17 = x13*x16;
auto x18 = cell[2] - cell[5];
auto x19 = -x18;
auto x20 = x19*x19;
auto x21 = x13*x20;
auto x22 = cell[3] - cell[6];
auto x23 = -x22;
auto x24 = x23*x23;
auto x25 = x13*x24;
auto x26 = x21 + x25 + V{-1};
auto x27 = V{0.125}*x10;
auto x28 = V{1} / (x11);
auto x29 = V{4}*cell[1] - V{4}*cell[4];
auto x30 = V{6}*x12;
auto x31 = V{4}*cell[2] - V{4}*cell[5];
auto x32 = x17 + V{-1};
auto x33 = V{4}*cell[3] - V{4}*cell[6];
auto x34 = x18*x18;
auto x35 = x13*x34;
auto x36 = x14*x14;
auto x37 = x22*x22;
auto x38 = x13*x37 + V{-1};
auto x39 = x13*x36;
cell[0] = -V{0.25}*x10*(x9*(x17 + x26) + V{1}) - x7*cell[0];
cell[1] = -x27*(x9*(-x16*x30 + x26 - x28*x29) + V{1}) - x7*cell[1];
cell[2] = -x27*(x9*(-x20*x30 + x25 - x28*x31 + x32) + V{1}) - x7*cell[2];
cell[3] = -x27*(x9*(x21 - x24*x30 - x28*x33 + x32) + V{1}) - x7*cell[3];
cell[4] = -x27*(x9*(x28*x29 - x30*x36 + x35 + x38) + V{1}) - x7*cell[4];
cell[5] = -x27*(x9*(x28*x31 - x30*x34 + x38 + x39) + V{1}) - x7*cell[5];
cell[6] = -x27*(x9*(x28*x33 - x30*x37 + x35 + x39 + V{-1}) + V{1}) - x7*cell[6];
return { x11, V{1}*x12*(x34 + x36 + x37) };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q7<FIELDS...>,momenta::BulkTuple,equilibria::Incompressible> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x10 = parameters.template get<olb::descriptors::OMEGA>();
auto x7 = cell[1] - cell[4];
auto x8 = x7*x7;
auto x9 = cell[2] - cell[5];
auto x11 = x9*x9;
auto x12 = cell[3] - cell[6];
auto x13 = x12*x12;
auto x14 = x10 + V{-1};
auto x15 = V{0.125}*cell[0];
auto x16 = -V{0.25}*x13 + x15 + V{0.125}*cell[3] + V{0.125}*cell[6];
auto x17 = -V{0.25}*x11 + V{0.125}*cell[2] + V{0.125}*cell[5];
auto x18 = x16 + x17 + V{0.75}*x8;
auto x19 = -V{0.25}*x8 + V{0.125}*cell[1] + V{0.125}*cell[4];
auto x20 = V{0.75}*x11 + x16 + x19;
auto x21 = V{0.75}*x13 + x15 + x17 + x19;
auto x22 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + V{1};
auto x0 = x10*(-V{0.5}*x11 - V{0.5}*x13 - V{0.5}*x8 + V{0.25}*cell[0] + V{0.25}*cell[1] + V{0.25}*cell[2] + V{0.25}*cell[3] + V{0.25}*cell[4] + V{0.25}*cell[5] + V{0.25}*cell[6]) - x14*cell[0];
auto x1 = x10*(x18 + V{0.625}*cell[1] - V{0.375}*cell[4]) - x14*cell[1];
auto x2 = x10*(x20 + V{0.625}*cell[2] - V{0.375}*cell[5]) - x14*cell[2];
auto x3 = x10*(x21 + V{0.625}*cell[3] - V{0.375}*cell[6]) - x14*cell[3];
auto x4 = x10*(x18 - V{0.375}*cell[1] + V{0.625}*cell[4]) - x14*cell[4];
auto x5 = x10*(x20 - V{0.375}*cell[2] + V{0.625}*cell[5]) - x14*cell[5];
auto x6 = x10*(x21 - V{0.375}*cell[3] + V{0.625}*cell[6]) - x14*cell[6];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
return { x22, V{1}*(x11 + x13 + x8)/((x22)*(x22)) };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x19 = x22 + V{-1};
auto x20 = cell[10] + cell[14];
auto x21 = cell[12] + cell[7];
auto x23 = x20 + x21 + cell[0] + cell[11] + cell[13] + cell[15] + cell[16] + cell[17] + cell[18] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + cell[9];
auto x24 = x23 + V{1};
auto x25 = x23 + V{1};
auto x26 = V{1} / ((x25)*(x25));
auto x27 = V{1.5}*x26;
auto x28 = cell[13] - cell[4];
auto x29 = cell[15] - cell[6];
auto x30 = x28 + x29;
auto x31 = -cell[1];
auto x32 = cell[16] - cell[7];
auto x33 = x31 + x32;
auto x34 = x20 - cell[5];
auto x35 = x30 + x33 + x34;
auto x36 = x35*x35;
auto x37 = x27*x36;
auto x38 = cell[17] - cell[8];
auto x39 = x28 + x38;
auto x40 = cell[18] - cell[9];
auto x41 = -cell[2];
auto x42 = x41 + cell[11] - cell[14] + cell[5];
auto x43 = x39 + x40 + x42;
auto x44 = x43*x43;
auto x45 = x27*x44;
auto x46 = x29 + x38;
auto x47 = -cell[3];
auto x48 = -cell[18] + cell[9];
auto x49 = x47 + x48;
auto x50 = x21 - cell[16];
auto x51 = x46 + x49 + x50;
auto x52 = x51*x51;
auto x53 = x27*x52;
auto x54 = x45 + x53 + V{-1};
auto x55 = x37 + x54;
auto x56 = V{0.0555555555555556}*x22;
auto x57 = V{1} / (x25);
auto x58 = V{3}*cell[14];
auto x59 = V{3}*cell[16];
auto x60 = V{3}*cell[5];
auto x61 = V{3}*cell[7];
auto x62 = V{3}*cell[13] - V{3}*cell[4];
auto x63 = V{3}*cell[15] - V{3}*cell[6];
auto x64 = x57*(x58 + x59 - x60 - x61 + x62 + x63 + V{3}*cell[10] - V{3}*cell[1]);
auto x65 = V{3}*x26;
auto x66 = x36*x65;
auto x67 = V{3}*cell[18];
auto x68 = V{3}*cell[9];
auto x69 = V{3}*cell[17] - V{3}*cell[8];
auto x70 = x57*(-x58 + x60 + x62 + x67 - x68 + x69 + V{3}*cell[11] - V{3}*cell[2]);
auto x71 = x44*x65;
auto x72 = x37 + V{-1};
auto x73 = x57*(-x59 + x61 + x63 - x67 + x68 + x69 + V{3}*cell[12] - V{3}*cell[3]);
auto x74 = x52*x65;
auto x75 = V{0.0277777777777778}*x22;
auto x76 = V{4.5}*x26;
auto x77 = x33 + cell[10];
auto x78 = x40 + x41 + x46 + x77 + cell[11] + V{2}*cell[13] - V{2}*cell[4];
auto x79 = x76*(x78*x78);
auto x80 = x55 + x64;
auto x81 = -x70;
auto x82 = -cell[17] + cell[8];
auto x83 = x29 + x48 + x77 + x82 - cell[11] + V{2}*cell[14] + cell[2] - V{2}*cell[5];
auto x84 = -x83;
auto x85 = x31 + x34;
auto x86 = x39 + x49 + x85 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x87 = x76*(x86*x86);
auto x88 = -x73;
auto x89 = x28 - cell[12] + cell[3];
auto x90 = x40 + x82 + x85 + x89 + V{2}*cell[16] - V{2}*cell[7];
auto x91 = -x90;
auto x92 = x30 + x42 + x47 + x50 + V{2}*cell[17] - V{2}*cell[8];
auto x93 = x76*(x92*x92);
auto x94 = x55 + x70;
auto x95 = x32 + x42 + x89 - cell[15] + V{2}*cell[18] + cell[6] - V{2}*cell[9];
auto x96 = -x95;
auto x97 = -x45;
auto x98 = V{1} - x53;
auto x99 = x97 + x98;
auto x100 = x64 + x99;
auto x101 = -x37;
auto x102 = x101 + x70;
auto x103 = x101 + x73;
auto x104 = -x64;
auto x105 = x55 + x73;
cell[0] = -x19*cell[0] - V{0.333333333333333}*x22*(x24*x55 + V{1});
cell[1] = -x19*cell[1] - x56*(x24*(x54 + x64 - x66) + V{1});
cell[2] = -x19*cell[2] - x56*(x24*(x53 + x70 - x71 + x72) + V{1});
cell[3] = -x19*cell[3] - x56*(x24*(x45 + x72 + x73 - x74) + V{1});
cell[4] = -x19*cell[4] - x75*(x24*(x70 - x79 + x80) + V{1});
cell[5] = -x19*cell[5] - x75*(x24*(-x76*x84*x84 + x80 + x81) + V{1});
cell[6] = -x19*cell[6] - x75*(x24*(x73 + x80 - x87) + V{1});
cell[7] = -x19*cell[7] - x75*(x24*(-x76*x91*x91 + x80 + x88) + V{1});
cell[8] = -x19*cell[8] - x75*(x24*(x73 - x93 + x94) + V{1});
cell[9] = -x19*cell[9] - x75*(x24*(-x76*x96*x96 + x88 + x94) + V{1});
cell[10] = -x19*cell[10] + x56*(x24*(x100 + x66) + V{-1});
cell[11] = -x19*cell[11] + x56*(x24*(x102 + x71 + x98) + V{-1});
cell[12] = -x19*cell[12] + x56*(x24*(x103 + x74 + x97 + V{1}) + V{-1});
cell[13] = -x19*cell[13] + x75*(x24*(x100 + x102 + x79) + V{-1});
cell[14] = -x19*cell[14] - x75*(x24*(x104 - x76*x83*x83 + x94) + V{1});
cell[15] = -x19*cell[15] + x75*(x24*(x100 + x103 + x87) + V{-1});
cell[16] = -x19*cell[16] - x75*(x24*(x104 + x105 - x76*x90*x90) + V{1});
cell[17] = -x19*cell[17] + x75*(x24*(x102 + x73 + x93 + x99) + V{-1});
cell[18] = -x19*cell[18] - x75*(x24*(x105 - x76*x95*x95 + x81) + V{1});
return { x25, V{1}*x26*(x36 + x44 + x52) };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::Incompressible> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x19 = cell[13] - cell[4];
auto x20 = cell[15] - cell[6];
auto x21 = cell[10] + cell[14] + cell[16];
auto x23 = x19 + x20 + x21 - cell[1] - cell[5] - cell[7];
auto x24 = x23*x23;
auto x25 = cell[17] - cell[8];
auto x26 = cell[11] + cell[18] + cell[5];
auto x27 = x19 + x25 + x26 - cell[14] - cell[2] - cell[9];
auto x28 = x27*x27;
auto x29 = cell[12] + cell[7] + cell[9];
auto x30 = x20 + x25 + x29 - cell[16] - cell[18] - cell[3];
auto x31 = x30*x30;
auto x32 = x22 + V{-1};
auto x33 = V{0.111111111111111}*cell[10];
auto x34 = V{0.0555555555555556}*cell[0];
auto x35 = V{0.0555555555555556}*cell[3];
auto x36 = V{0.0555555555555556}*cell[12];
auto x37 = V{0.111111111111111}*cell[13];
auto x38 = -V{0.0833333333333333}*x31;
auto x39 = x34 + x35 + x36 - x37 + x38 + V{0.222222222222222}*cell[4];
auto x40 = V{0.0555555555555556}*cell[2];
auto x41 = V{0.0555555555555556}*cell[11];
auto x42 = V{0.111111111111111}*cell[15];
auto x43 = -V{0.0833333333333333}*x28;
auto x44 = x40 + x41 - x42 + x43 + V{0.222222222222222}*cell[6];
auto x45 = V{0.111111111111111}*cell[14];
auto x46 = -x45 + V{0.222222222222222}*cell[5];
auto x47 = V{0.111111111111111}*cell[16];
auto x48 = -x47 + V{0.222222222222222}*cell[7];
auto x49 = V{0.0555555555555556}*cell[8];
auto x50 = V{0.0555555555555556}*cell[9];
auto x51 = V{0.0555555555555556}*cell[17];
auto x52 = V{0.0555555555555556}*cell[18];
auto x53 = V{0.166666666666667}*x24 + x49 + x50 + x51 + x52;
auto x54 = V{0.111111111111111}*cell[11];
auto x55 = V{0.111111111111111}*cell[5];
auto x56 = -x55 + V{0.222222222222222}*cell[14];
auto x57 = V{0.0555555555555556}*cell[1];
auto x58 = V{0.0555555555555556}*cell[10];
auto x59 = V{0.111111111111111}*cell[17];
auto x60 = -V{0.0833333333333333}*x24;
auto x61 = x57 + x58 - x59 + x60 + V{0.222222222222222}*cell[8];
auto x62 = V{0.111111111111111}*cell[18];
auto x63 = -x62 + V{0.222222222222222}*cell[9];
auto x64 = V{0.0555555555555556}*cell[6];
auto x65 = V{0.0555555555555556}*cell[7];
auto x66 = V{0.0555555555555556}*cell[15];
auto x67 = V{0.0555555555555556}*cell[16];
auto x68 = V{0.166666666666667}*x28 + x64 + x65 + x66 + x67;
auto x69 = V{0.111111111111111}*cell[12];
auto x70 = V{0.111111111111111}*cell[7];
auto x71 = x34 - x70 + V{0.222222222222222}*cell[16];
auto x72 = V{0.111111111111111}*cell[9];
auto x73 = -x72 + V{0.222222222222222}*cell[18];
auto x74 = V{0.0555555555555556}*cell[4];
auto x75 = V{0.0555555555555556}*cell[5];
auto x76 = V{0.0555555555555556}*cell[13];
auto x77 = V{0.0555555555555556}*cell[14];
auto x78 = V{0.166666666666667}*x31 + x74 + x75 + x76 + x77;
auto x79 = V{0.0277777777777778}*cell[0];
auto x80 = -V{0.0416666666666667}*x24;
auto x81 = -V{0.0416666666666667}*x28;
auto x82 = -V{0.0416666666666667}*x31;
auto x83 = -x52 + x72 + x79 + x80 + x81 + x82;
auto x84 = -x67 + x70;
auto x85 = V{0.111111111111111}*cell[1];
auto x86 = -x58;
auto x87 = V{0.111111111111111}*cell[8];
auto x88 = -x51 + x87;
auto x89 = x85 + x86 + x88;
auto x90 = V{0.111111111111111}*cell[2];
auto x91 = -x41;
auto x92 = V{0.111111111111111}*cell[6];
auto x93 = -x66 + x92;
auto x94 = x90 + x91 + x93;
auto x95 = V{0.0277777777777778}*cell[3];
auto x96 = V{0.0277777777777778}*cell[12];
auto x97 = V{1}*cell[10];
auto x98 = V{1}*cell[17];
auto x99 = -V{1}*cell[1];
auto x100 = V{1}*cell[8];
auto x101 = -x100 + x97 + x98 + x99;
auto x102 = V{1}*cell[18];
auto x103 = V{1}*cell[9];
auto x104 = x102 - x103;
auto x105 = V{1}*cell[11];
auto x106 = V{1}*cell[15];
auto x107 = V{1}*cell[2];
auto x108 = -x107;
auto x109 = V{1}*cell[6];
auto x110 = -x109;
auto x111 = x105 + x106 + x108 + x110;
auto x112 = V{1}*cell[16];
auto x113 = V{1}*cell[7];
auto x114 = x112 - x113;
auto x115 = V{4.5}*cell[10];
auto x116 = V{4.5}*cell[17];
auto x117 = -V{4.5}*cell[1];
auto x118 = V{4.5}*cell[8];
auto x119 = x115 + x116 + x117 - x118;
auto x120 = V{4.5}*cell[18];
auto x121 = V{4.5}*cell[9];
auto x122 = x120 - x121;
auto x123 = V{4.5}*cell[11];
auto x124 = V{4.5}*cell[15];
auto x125 = V{4.5}*cell[2];
auto x126 = -x125;
auto x127 = V{4.5}*cell[6];
auto x128 = -x127;
auto x129 = x123 + x124 + x126 + x128;
auto x130 = V{4.5}*cell[16];
auto x131 = V{4.5}*cell[7];
auto x132 = x130 - x131;
auto x133 = x95 + x96 + V{0.0277777777777778}*(x101 + x104 + x111 + x114 + V{2}*cell[13] - V{2}*cell[4])*(x119 + x122 + x129 + x132 + V{9}*cell[13] - V{9}*cell[4]) + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[5];
auto x134 = -x49 + x59;
auto x135 = x134 + x85 + x86;
auto x136 = -x102 + x103;
auto x137 = x100 + x97 - x98 + x99;
auto x138 = -x120 + x121;
auto x139 = x115 - x116 + x117 + x118;
auto x140 = x95 + x96 + V{0.0277777777777778}*(-x105 + x106 + x107 + x110 + x114 + x136 + x137 + V{2}*cell[14] - V{2}*cell[5])*(-x123 + x124 + x125 + x128 + x132 + x138 + x139 + V{9}*cell[14] - V{9}*cell[5]) + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[4];
auto x141 = -x50 + x62;
auto x142 = -x40;
auto x143 = x79 + x80 + x81 + x82;
auto x144 = x143 + x84;
auto x145 = x142 + x144 + x54;
auto x146 = x141 + x143;
auto x147 = x55 - x77;
auto x148 = V{0.111111111111111}*cell[3];
auto x149 = -x36;
auto x150 = V{0.111111111111111}*cell[4];
auto x151 = x150 - x76;
auto x152 = x148 + x149 + x151;
auto x153 = V{0.0277777777777778}*cell[2];
auto x154 = V{0.0277777777777778}*cell[11];
auto x155 = V{1}*cell[14];
auto x156 = V{1}*cell[5];
auto x157 = V{1}*cell[13] - V{1}*cell[4];
auto x158 = x155 - x156 + x157;
auto x159 = V{1}*cell[12];
auto x160 = V{1}*cell[3];
auto x161 = x159 - x160;
auto x162 = V{4.5}*cell[14];
auto x163 = V{4.5}*cell[5];
auto x164 = V{4.5}*cell[13] - V{4.5}*cell[4];
auto x165 = x162 - x163 + x164;
auto x166 = V{4.5}*cell[12];
auto x167 = V{4.5}*cell[3];
auto x168 = x166 - x167;
auto x169 = x153 + x154 + V{0.0277777777777778}*(x101 + x136 + x158 + x161 + V{2}*cell[15] - V{2}*cell[6])*(x119 + x138 + x165 + x168 + V{9}*cell[15] - V{9}*cell[6]) + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[7];
auto x170 = -x35;
auto x171 = x151 + x170 + x69;
auto x172 = -x159 + x160;
auto x173 = -x166 + x167;
auto x174 = x153 + x154 + V{0.0277777777777778}*(x104 + x137 + x158 + x172 + V{2}*cell[16] - V{2}*cell[7])*(x122 + x139 + x165 + x173 + V{9}*cell[16] - V{9}*cell[7]) + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[6];
auto x175 = V{0.0277777777777778}*cell[1];
auto x176 = V{0.0277777777777778}*cell[10];
auto x177 = x45 - x75;
auto x178 = x175 + x176 + x177;
auto x179 = -x155 + x156 + x157;
auto x180 = -x162 + x163 + x164;
auto x181 = V{0.0277777777777778}*(x111 - x112 + x113 + x161 + x179 + V{2}*cell[17] - V{2}*cell[8])*(x129 - x130 + x131 + x168 + x180 + V{9}*cell[17] - V{9}*cell[8]) + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[9];
auto x182 = x47 - x65;
auto x183 = x143 + x182;
auto x184 = V{0.0277777777777778}*(x105 - x106 + x108 + x109 + x114 + x172 + x179 + V{2}*cell[18] - V{2}*cell[9])*(x123 - x124 + x126 + x127 + x132 + x173 + x180 + V{9}*cell[18] - V{9}*cell[9]) + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[8];
auto x185 = x42 - x64;
auto x186 = x185 + x90 + x91;
auto x187 = -x150 + x35 + x36 + x38 + V{0.222222222222222}*cell[13];
auto x188 = x40 + x41 + x43 - x92 + V{0.222222222222222}*cell[15];
auto x189 = x34 + x57 + x58 + x60 - x87 + V{0.222222222222222}*cell[17];
auto x190 = x142 + x54;
auto x191 = -x57;
auto x192 = x182 + x191 + x33;
auto x193 = x37 - x74;
auto x194 = x170 + x193 + x69;
auto x195 = x177 + x191 + x33;
auto x196 = x148 + x149 + x193;
auto x197 = x147 + x175 + x176;
auto x198 = x21 + x26 + x29 + cell[0] + cell[13] + cell[15] + cell[17] + cell[1] + cell[2] + cell[3] + cell[4] + cell[6] + cell[8] + V{1};
auto x0 = x22*(-V{0.5}*x24 - V{0.5}*x28 - V{0.5}*x31 + V{0.333333333333333}*cell[0] + V{0.333333333333333}*cell[10] + V{0.333333333333333}*cell[11] + V{0.333333333333333}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9]) - x32*cell[0];
auto x1 = x22*(-x33 + x39 + x44 + x46 + x48 + x53 + V{0.222222222222222}*cell[1]) - x32*cell[1];
auto x2 = x22*(x39 - x54 + x56 + x61 + x63 + x68 + V{0.222222222222222}*cell[2]) - x32*cell[2];
auto x3 = x22*(x44 + x61 - x69 + x71 + x73 + x78 + V{0.222222222222222}*cell[3]) - x32*cell[3];
auto x4 = x22*(x133 + x83 + x84 + x89 + x94 - V{0.138888888888889}*cell[13] + V{0.194444444444444}*cell[4]) - x32*cell[4];
auto x5 = x22*(x135 + x140 + x141 + x145 + x93 - V{0.138888888888889}*cell[14] + V{0.194444444444444}*cell[5]) - x32*cell[5];
auto x6 = x22*(x146 + x147 + x152 + x169 + x89 - V{0.138888888888889}*cell[15] + V{0.194444444444444}*cell[6]) - x32*cell[6];
auto x7 = x22*(x135 + x147 + x171 + x174 + x83 - V{0.138888888888889}*cell[16] + V{0.194444444444444}*cell[7]) - x32*cell[7];
auto x8 = x22*(x152 + x178 + x181 + x183 + x94 - V{0.138888888888889}*cell[17] + V{0.194444444444444}*cell[8]) - x32*cell[8];
auto x9 = x22*(x144 + x171 + x178 + x184 + x186 - V{0.138888888888889}*cell[18] + V{0.194444444444444}*cell[9]) - x32*cell[9];
auto x10 = x22*(x187 + x188 + x53 + x56 + x71 - x85 + V{0.222222222222222}*cell[10]) - x32*cell[10];
auto x11 = x22*(x187 + x189 + x46 + x68 + x73 - x90 + V{0.222222222222222}*cell[11]) - x32*cell[11];
auto x12 = x22*(-x148 + x188 + x189 + x48 + x63 + x78 + V{0.222222222222222}*cell[12]) - x32*cell[12];
auto x13 = x22*(x133 + x134 + x146 + x185 + x190 + x192 + V{0.194444444444444}*cell[13] - V{0.138888888888889}*cell[4]) - x32*cell[13];
auto x14 = x22*(x140 + x186 + x192 + x83 + x88 + V{0.194444444444444}*cell[14] - V{0.138888888888889}*cell[5]) - x32*cell[14];
auto x15 = x22*(x134 + x169 + x194 + x195 + x83 + V{0.194444444444444}*cell[15] - V{0.138888888888889}*cell[6]) - x32*cell[15];
auto x16 = x22*(x146 + x174 + x195 + x196 + x88 + V{0.194444444444444}*cell[16] - V{0.138888888888889}*cell[7]) - x32*cell[16];
auto x17 = x22*(x145 + x181 + x185 + x194 + x197 + V{0.194444444444444}*cell[17] - V{0.138888888888889}*cell[8]) - x32*cell[17];
auto x18 = x22*(x183 + x184 + x190 + x196 + x197 + x93 + V{0.194444444444444}*cell[18] - V{0.138888888888889}*cell[9]) - x32*cell[18];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { x198, V{1}*(x24 + x28 + x31)/((x198)*(x198)) };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x30 = parameters.template get<olb::descriptors::OMEGA>();
auto x27 = x30 + V{-1};
auto x28 = cell[8] + cell[9];
auto x29 = cell[15] + cell[21];
auto x31 = cell[11] + cell[26];
auto x32 = x28 + x29 + x31 + cell[0] + cell[10] + cell[12] + cell[13] + cell[14] + cell[16] + cell[17] + cell[18] + cell[19] + cell[1] + cell[20] + cell[22] + cell[23] + cell[24] + cell[25] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7];
auto x33 = x32 + V{1};
auto x34 = x32 + V{1};
auto x35 = V{1} / ((x34)*(x34));
auto x36 = V{1.5}*x35;
auto x37 = -cell[17];
auto x38 = -cell[19];
auto x39 = x37 + x38 + cell[4] + cell[6];
auto x40 = -cell[24];
auto x41 = cell[10] - cell[23];
auto x42 = x40 + x41 + cell[11];
auto x43 = cell[12] - cell[25];
auto x44 = -cell[14];
auto x45 = -cell[20] + cell[7];
auto x46 = x44 + x45 + cell[1];
auto x47 = -cell[18] + cell[5];
auto x48 = cell[13] - cell[26];
auto x49 = x39 + x42 + x43 + x46 + x47 + x48;
auto x50 = -x49;
auto x51 = x50*x50;
auto x52 = x36*x51;
auto x53 = -cell[13];
auto x54 = -cell[21];
auto x55 = x53 + x54 + cell[26] + cell[8];
auto x56 = -cell[22];
auto x57 = x37 + cell[4];
auto x58 = x56 + x57 + cell[9];
auto x59 = -cell[15];
auto x60 = x59 + cell[18] + cell[2] - cell[5];
auto x61 = -cell[12] + cell[25];
auto x62 = x42 + x55 + x58 + x60 + x61;
auto x63 = -x62;
auto x64 = x63*x63;
auto x65 = x36*x64;
auto x66 = -cell[16];
auto x67 = x43 + x66 + cell[3];
auto x68 = -cell[9];
auto x69 = x38 + cell[6];
auto x70 = x68 + x69 + cell[22];
auto x71 = cell[20] - cell[7];
auto x72 = x41 - cell[11] + cell[24];
auto x73 = x55 + x67 + x70 + x71 + x72;
auto x74 = -x73;
auto x75 = x74*x74;
auto x76 = x36*x75;
auto x77 = x65 + x76 + V{-1};
auto x78 = x52 + x77;
auto x79 = V{0.0740740740740741}*x30;
auto x80 = V{1} / (x34);
auto x81 = V{3}*cell[5];
auto x82 = V{3}*cell[7];
auto x83 = V{3}*cell[13];
auto x84 = V{3}*cell[18];
auto x85 = V{3}*cell[20];
auto x86 = V{3}*cell[26];
auto x87 = V{3}*cell[10];
auto x88 = V{3}*cell[11];
auto x89 = -V{3}*cell[23];
auto x90 = V{3}*cell[24];
auto x91 = x87 + x88 + x89 - x90 - V{3}*cell[17] + V{3}*cell[4];
auto x92 = V{3}*cell[12];
auto x93 = V{3}*cell[25];
auto x94 = x92 - x93 - V{3}*cell[19] + V{3}*cell[6];
auto x95 = x81 + x82 + x83 - x84 - x85 - x86 + x91 + x94 - V{3}*cell[14] + V{3}*cell[1];
auto x96 = -x80*x95;
auto x97 = V{3}*x35;
auto x98 = V{3}*cell[9];
auto x99 = V{3}*cell[22];
auto x100 = -x83 + x86 - V{3}*cell[21] + V{3}*cell[8];
auto x101 = x100 - x81 + x84 + x91 - x92 + x93 + x98 - x99 - V{3}*cell[15] + V{3}*cell[2];
auto x102 = -x101*x80;
auto x103 = x52 + V{-1};
auto x104 = x100 - x82 + x85 + x87 - x88 + x89 + x90 + x94 - x98 + x99 - V{3}*cell[16] + V{3}*cell[3];
auto x105 = -x104*x80;
auto x106 = V{0.0185185185185185}*x30;
auto x107 = V{4.5}*x35;
auto x108 = V{2}*cell[11] - V{2}*cell[24];
auto x109 = V{2}*cell[10] - V{2}*cell[23];
auto x110 = x109 + x54;
auto x111 = x59 + cell[2];
auto x112 = x111 - V{2}*cell[17] + V{2}*cell[4];
auto x113 = x108 + x110 + x112 + x28 + x46 + x56 + x69;
auto x114 = -x113;
auto x115 = x78 + x96;
auto x116 = x102 + x115;
auto x117 = V{2}*cell[25];
auto x118 = V{2}*cell[12];
auto x119 = -x117 + x118;
auto x120 = V{2}*cell[26];
auto x121 = V{2}*cell[13];
auto x122 = -x120 + x121 - cell[8];
auto x123 = V{2}*cell[18];
auto x124 = V{2}*cell[5];
auto x125 = -x123 + x124 - cell[2];
auto x126 = x119 + x122 + x125 + x29 + x46 + x70;
auto x127 = -x102;
auto x128 = x115 + x127;
auto x129 = x44 + cell[1];
auto x130 = x129 + x47;
auto x131 = x66 + cell[3];
auto x132 = -V{2}*cell[19] + V{2}*cell[6];
auto x133 = x131 + x132;
auto x134 = x110 + x119 + x130 + x133 + x57 + x68 + cell[22] + cell[8];
auto x135 = -x134;
auto x136 = -x105;
auto x137 = -cell[3];
auto x138 = x108 + x137 + cell[16];
auto x139 = V{2}*cell[20];
auto x140 = V{2}*cell[7];
auto x141 = -x139 + x140;
auto x142 = x122 + x130 + x138 + x141 + x58 + cell[21];
auto x143 = -V{2}*cell[21] + V{2}*cell[8];
auto x144 = x131 + x143;
auto x145 = x109 + x120 - x121 + x144 + x39 + x60 + x71;
auto x146 = -x145;
auto x147 = x102 + x78;
auto x148 = x105 + x147;
auto x149 = V{2}*cell[22];
auto x150 = V{2}*cell[9];
auto x151 = -x149 + x150;
auto x152 = x117 - x118 + x138 + x151 + x45 + x57 + x60 + cell[19] - cell[6];
auto x153 = V{0.00462962962962963}*x30;
auto x154 = x112 + x129;
auto x155 = x132 + x143 + x154 + x31 + x40 + x53 + x67 + V{3}*cell[10] - V{3}*cell[23];
auto x156 = -x155;
auto x157 = x137 + x141 + x151 + x154 + x41 + x48 + x61 + V{3}*cell[11] + cell[16] - V{3}*cell[24];
auto x158 = x125 + x129 + x133 + x149 - x150 + x48 + x72 + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x159 = x80*x95;
auto x160 = x111 + x123 - x124 + x139 - x140 + x144 + x61 + x72 - V{3}*cell[13] + cell[14] - cell[1] + V{3}*cell[26];
auto x161 = -x160;
auto x162 = x104*x80;
auto x163 = x62*x62;
auto x164 = x163*x36;
auto x165 = x73*x73;
auto x166 = x165*x36 + V{-1};
auto x167 = x164 + x166;
auto x168 = x101*x80;
auto x169 = x49*x49;
auto x170 = x169*x36;
auto x171 = x168 + x170;
auto x172 = x162 + x167 + x171;
auto x173 = x159 + x167;
auto x174 = x162 + x170;
auto x175 = x171 + x173;
auto x176 = -x96;
auto x177 = -x126;
auto x178 = x173 + x174;
auto x179 = -x142;
auto x180 = x105 + x78;
auto x181 = -x152;
auto x182 = -x157;
auto x183 = -x158;
cell[0] = -x27*cell[0] - V{0.296296296296296}*x30*(x33*x78 + V{1});
cell[1] = -x27*cell[1] - x79*(x33*(-x51*x97 + x77 + x96) + V{1});
cell[2] = -x27*cell[2] - x79*(x33*(x102 + x103 - x64*x97 + x76) + V{1});
cell[3] = -x27*cell[3] - x79*(x33*(x103 + x105 + x65 - x75*x97) + V{1});
cell[4] = -x106*(x33*(-x107*x114*x114 + x116) + V{1}) - x27*cell[4];
cell[5] = -x106*(x33*(-x107*x126*x126 + x128) + V{1}) - x27*cell[5];
cell[6] = -x106*(x33*(x105 - x107*x135*x135 + x115) + V{1}) - x27*cell[6];
cell[7] = -x106*(x33*(-x107*x142*x142 + x115 + x136) + V{1}) - x27*cell[7];
cell[8] = -x106*(x33*(-x107*x146*x146 + x148) + V{1}) - x27*cell[8];
cell[9] = -x106*(x33*(-x107*x152*x152 + x136 + x147) + V{1}) - x27*cell[9];
cell[10] = -x153*(x33*(x105 - x107*x156*x156 + x116) + V{1}) - x27*cell[10];
cell[11] = -x153*(x33*(-x107*x157*x157 + x116 + x136) + V{1}) - x27*cell[11];
cell[12] = -x153*(x33*(x105 - x107*x158*x158 + x128) + V{1}) - x27*cell[12];
cell[13] = -x153*(x33*(-x107*x161*x161 - x159 + x172) + V{1}) - x27*cell[13];
cell[14] = -x27*cell[14] - x79*(x33*(-x169*x97 + x173) + V{1});
cell[15] = -x27*cell[15] - x79*(x33*(-x163*x97 + x166 + x171) + V{1});
cell[16] = -x27*cell[16] - x79*(x33*(x164 - x165*x97 + x174 + V{-1}) + V{1});
cell[17] = -x106*(x33*(-x107*x113*x113 + x175) + V{1}) - x27*cell[17];
cell[18] = -x106*(x33*(-x107*x177*x177 + x147 + x176) + V{1}) - x27*cell[18];
cell[19] = -x106*(x33*(-x107*x134*x134 + x178) + V{1}) - x27*cell[19];
cell[20] = -x106*(x33*(-x107*x179*x179 + x176 + x180) + V{1}) - x27*cell[20];
cell[21] = -x106*(x33*(-x107*x145*x145 + x172) + V{1}) - x27*cell[21];
cell[22] = -x106*(x33*(-x107*x181*x181 + x127 + x180) + V{1}) - x27*cell[22];
cell[23] = -x153*(x33*(-x107*x155*x155 + x162 + x175) + V{1}) - x27*cell[23];
cell[24] = -x153*(x33*(-x107*x182*x182 - x162 + x175) + V{1}) - x27*cell[24];
cell[25] = -x153*(x33*(-x107*x183*x183 - x168 + x178) + V{1}) - x27*cell[25];
cell[26] = -x153*(x33*(-x107*x160*x160 + x148 + x176) + V{1}) - x27*cell[26];
return { x34, V{1}*x35*(x163 + x165 + x169) };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::Incompressible> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x30 = parameters.template get<olb::descriptors::OMEGA>();
auto x27 = V{0.296296296296296}*cell[16];
auto x28 = -cell[23];
auto x29 = x28 + cell[10] - cell[13] - cell[21] + cell[26] + cell[8];
auto x31 = cell[11] - cell[17] - cell[24] + cell[4];
auto x32 = cell[18] + cell[25] + cell[2] + cell[9];
auto x33 = x29 + x31 + x32 - cell[12] - cell[15] - cell[22] - cell[5];
auto x34 = x33*x33;
auto x35 = cell[12] - cell[19] - cell[25] + cell[6];
auto x36 = cell[20] + cell[22] + cell[24] + cell[3];
auto x37 = x29 + x35 + x36 - cell[11] - cell[16] - cell[7] - cell[9];
auto x38 = x37*x37;
auto x39 = cell[10] + cell[13] + cell[1] + cell[5] + cell[7];
auto x40 = x28 + x31 + x35 + x39 - cell[14] - cell[18] - cell[20] - cell[26];
auto x41 = x40*x40;
auto x42 = V{0.296296296296296}*cell[4];
auto x43 = V{0.296296296296296}*cell[5];
auto x44 = V{0.296296296296296}*cell[6];
auto x45 = V{0.296296296296296}*cell[7];
auto x46 = V{0.296296296296296}*cell[10];
auto x47 = V{0.296296296296296}*cell[11];
auto x48 = V{0.296296296296296}*cell[12];
auto x49 = V{0.296296296296296}*cell[13];
auto x50 = x42 + x43 + x44 + x45 + x46 + x47 + x48 + x49 + V{0.296296296296296}*cell[1];
auto x51 = V{0.296296296296296}*cell[8];
auto x52 = V{0.296296296296296}*cell[9];
auto x53 = V{0.296296296296296}*cell[18];
auto x54 = V{0.296296296296296}*cell[25];
auto x55 = V{0.296296296296296}*cell[26];
auto x56 = x51 + x52 + x53 + x54 + x55 + V{0.296296296296296}*cell[2];
auto x57 = V{0.296296296296296}*cell[20];
auto x58 = V{0.296296296296296}*cell[22];
auto x59 = V{0.296296296296296}*cell[24];
auto x60 = x57 + x58 + x59 + V{0.296296296296296}*cell[3];
auto x61 = V{0.296296296296296}*cell[17];
auto x62 = V{0.296296296296296}*cell[19];
auto x63 = V{0.296296296296296}*cell[23];
auto x64 = x61 + x62 + x63 + V{0.296296296296296}*cell[14];
auto x65 = V{0.296296296296296}*cell[21];
auto x66 = x65 + V{0.296296296296296}*cell[15];
auto x67 = x30 + V{-1};
auto x68 = -V{0.148148148148148}*cell[20];
auto x69 = V{0.0740740740740741}*cell[0];
auto x70 = -V{0.148148148148148}*cell[23];
auto x71 = -V{0.148148148148148}*cell[24];
auto x72 = -V{0.111111111111111}*x38;
auto x73 = x69 + x70 + x71 + x72 - V{0.148148148148148}*cell[17];
auto x74 = -V{0.148148148148148}*cell[25];
auto x75 = -V{0.111111111111111}*x34;
auto x76 = x74 + x75 - V{0.148148148148148}*cell[19];
auto x77 = -V{0.148148148148148}*cell[26];
auto x78 = x77 - V{0.148148148148148}*cell[18];
auto x79 = V{0.0740740740740741}*cell[2];
auto x80 = V{0.0740740740740741}*cell[3];
auto x81 = x79 + x80;
auto x82 = V{0.0740740740740741}*cell[15];
auto x83 = V{0.0740740740740741}*cell[16];
auto x84 = x82 + x83;
auto x85 = V{0.0740740740740741}*cell[8];
auto x86 = V{0.0740740740740741}*cell[9];
auto x87 = x85 + x86;
auto x88 = V{0.0740740740740741}*cell[21];
auto x89 = V{0.0740740740740741}*cell[22];
auto x90 = x88 + x89;
auto x91 = V{0.222222222222222}*x41 + x81 + x84 + x87 + x90;
auto x92 = -V{0.148148148148148}*cell[12];
auto x93 = -V{0.148148148148148}*cell[13];
auto x94 = x92 + x93 - V{0.148148148148148}*cell[5];
auto x95 = -V{0.111111111111111}*x41;
auto x96 = x46 + x95 - V{0.148148148148148}*cell[21];
auto x97 = x47 - V{0.148148148148148}*cell[22];
auto x98 = V{0.0740740740740741}*cell[1];
auto x99 = x80 + x98;
auto x100 = V{0.0740740740740741}*cell[6];
auto x101 = V{0.0740740740740741}*cell[20];
auto x102 = x100 + x101;
auto x103 = V{0.0740740740740741}*cell[14];
auto x104 = x103 + x83;
auto x105 = V{0.0740740740740741}*cell[7];
auto x106 = V{0.0740740740740741}*cell[19];
auto x107 = x105 + x106;
auto x108 = x102 + x104 + x107 + V{0.222222222222222}*x34 + x99;
auto x109 = -V{0.148148148148148}*cell[11];
auto x110 = x109 + x55 + x69 - V{0.148148148148148}*cell[7];
auto x111 = x48 - V{0.148148148148148}*cell[9];
auto x112 = x79 + x98;
auto x113 = V{0.0740740740740741}*cell[4];
auto x114 = V{0.0740740740740741}*cell[5];
auto x115 = x113 + x114;
auto x116 = x103 + x82;
auto x117 = V{0.0740740740740741}*cell[17];
auto x118 = V{0.0740740740740741}*cell[18];
auto x119 = x117 + x118;
auto x120 = x112 + x115 + x116 + x119 + V{0.222222222222222}*x38;
auto x121 = V{0.0185185185185185}*cell[0];
auto x122 = V{0.0185185185185185}*cell[26];
auto x123 = -V{0.037037037037037}*cell[22];
auto x124 = -V{0.0277777777777778}*x34;
auto x125 = -V{0.0277777777777778}*x38;
auto x126 = -V{0.0277777777777778}*x41;
auto x127 = x121 + x122 + x123 + x124 + x125 + x126;
auto x128 = V{0.0185185185185185}*cell[25];
auto x129 = -V{0.037037037037037}*cell[21];
auto x130 = x128 + x129;
auto x131 = V{0.12962962962963}*cell[10];
auto x132 = -V{0.037037037037037}*cell[14];
auto x133 = -V{0.0925925925925926}*cell[23];
auto x134 = x131 + x132 + x133;
auto x135 = -V{0.037037037037037}*cell[15];
auto x136 = -V{0.037037037037037}*cell[19];
auto x137 = x135 + x136;
auto x138 = -V{0.037037037037037}*cell[20];
auto x139 = V{0.12962962962963}*cell[11] - V{0.0925925925925926}*cell[24];
auto x140 = x138 + x139;
auto x141 = x100 + x105;
auto x142 = V{1}*cell[6];
auto x143 = V{1}*cell[7];
auto x144 = V{1}*cell[19];
auto x145 = -x144;
auto x146 = V{1}*cell[20];
auto x147 = -x146;
auto x148 = V{1}*cell[1];
auto x149 = V{1}*cell[14];
auto x150 = x148 - x149;
auto x151 = x142 + x143 + x145 + x147 + x150;
auto x152 = V{1}*cell[8];
auto x153 = V{2}*cell[10];
auto x154 = V{1}*cell[21];
auto x155 = -V{2}*cell[23];
auto x156 = x152 + x153 - x154 + x155;
auto x157 = V{1}*cell[9];
auto x158 = V{2}*cell[11];
auto x159 = V{1}*cell[22];
auto x160 = -V{2}*cell[24];
auto x161 = x157 + x158 - x159 + x160;
auto x162 = V{1}*cell[2];
auto x163 = V{1}*cell[15];
auto x164 = x162 - x163;
auto x165 = x164 - V{2}*cell[17] + V{2}*cell[4];
auto x166 = V{4.5}*cell[6];
auto x167 = V{4.5}*cell[7];
auto x168 = V{4.5}*cell[19];
auto x169 = -x168;
auto x170 = V{4.5}*cell[20];
auto x171 = -x170;
auto x172 = V{4.5}*cell[1];
auto x173 = V{4.5}*cell[14];
auto x174 = x172 - x173;
auto x175 = x166 + x167 + x169 + x171 + x174;
auto x176 = V{4.5}*cell[8];
auto x177 = V{9}*cell[10];
auto x178 = V{4.5}*cell[21];
auto x179 = -V{9}*cell[23];
auto x180 = x176 + x177 - x178 + x179;
auto x181 = V{4.5}*cell[9];
auto x182 = V{9}*cell[11];
auto x183 = V{4.5}*cell[22];
auto x184 = -V{9}*cell[24];
auto x185 = x181 + x182 - x183 + x184;
auto x186 = V{4.5}*cell[2];
auto x187 = V{4.5}*cell[15];
auto x188 = x186 - x187;
auto x189 = x188 - V{9}*cell[17] + V{9}*cell[4];
auto x190 = V{0.0185185185185185}*cell[3];
auto x191 = V{0.0185185185185185}*cell[13];
auto x192 = x190 + x191;
auto x193 = V{0.0185185185185185}*cell[12];
auto x194 = V{0.0185185185185185}*cell[16];
auto x195 = x193 + x194;
auto x196 = x192 + x195 + V{0.0185185185185185}*(x151 + x156 + x161 + x165)*(x175 + x180 + x185 + x189) + V{0.0185185185185185}*cell[18] + V{0.0185185185185185}*cell[5];
auto x197 = V{0.0185185185185185}*cell[24];
auto x198 = -V{0.037037037037037}*cell[8];
auto x199 = x197 + x198;
auto x200 = -V{0.037037037037037}*cell[9];
auto x201 = V{0.0185185185185185}*cell[23];
auto x202 = x121 + x124 + x125 + x126;
auto x203 = x201 + x202;
auto x204 = x200 + x203;
auto x205 = -V{0.037037037037037}*cell[2];
auto x206 = x205 + x90;
auto x207 = V{0.12962962962963}*cell[13];
auto x208 = -V{0.0925925925925926}*cell[26];
auto x209 = x138 + x207 + x208;
auto x210 = x132 + x98;
auto x211 = V{0.12962962962963}*cell[12] - V{0.0925925925925926}*cell[25];
auto x212 = x136 + x211 + x82;
auto x213 = V{2}*cell[12];
auto x214 = V{2}*cell[25];
auto x215 = -x157 + x159 + x213 - x214;
auto x216 = V{2}*cell[13];
auto x217 = V{2}*cell[26];
auto x218 = -x152 + x154 + x216 - x217;
auto x219 = V{2}*cell[5];
auto x220 = V{2}*cell[18];
auto x221 = -x162 + x163 + x219 - x220;
auto x222 = V{9}*cell[12];
auto x223 = V{9}*cell[25];
auto x224 = -x181 + x183 + x222 - x223;
auto x225 = V{9}*cell[13];
auto x226 = V{9}*cell[26];
auto x227 = -x176 + x178 + x225 - x226;
auto x228 = V{9}*cell[5];
auto x229 = V{9}*cell[18];
auto x230 = -x186 + x187 + x228 - x229;
auto x231 = V{0.0185185185185185}*cell[11];
auto x232 = x190 + x231;
auto x233 = V{0.0185185185185185}*cell[10];
auto x234 = x194 + x233;
auto x235 = x232 + x234 + V{0.0185185185185185}*(x151 + x215 + x218 + x221)*(x175 + x224 + x227 + x230) + V{0.0185185185185185}*cell[17] + V{0.0185185185185185}*cell[4];
auto x236 = V{0.0185185185185185}*cell[15];
auto x237 = x197 + x236;
auto x238 = -V{0.037037037037037}*cell[17];
auto x239 = x191 + x238;
auto x240 = x200 + x202;
auto x241 = V{0.0185185185185185}*cell[2];
auto x242 = x122 + x241;
auto x243 = x231 + x242;
auto x244 = -V{0.037037037037037}*cell[16];
auto x245 = -V{0.037037037037037}*cell[18];
auto x246 = x244 + x245;
auto x247 = x85 + x89;
auto x248 = -V{1}*cell[17] + V{1}*cell[4];
auto x249 = V{1}*cell[3];
auto x250 = V{1}*cell[16];
auto x251 = x249 - x250;
auto x252 = x248 + x251;
auto x253 = V{1}*cell[5];
auto x254 = V{1}*cell[18];
auto x255 = x150 + x253 - x254;
auto x256 = -V{2}*cell[19] + V{2}*cell[6];
auto x257 = -V{4.5}*cell[17] + V{4.5}*cell[4];
auto x258 = V{4.5}*cell[3];
auto x259 = V{4.5}*cell[16];
auto x260 = x258 - x259;
auto x261 = x257 + x260;
auto x262 = V{4.5}*cell[5];
auto x263 = V{4.5}*cell[18];
auto x264 = x174 + x262 - x263;
auto x265 = -V{9}*cell[19] + V{9}*cell[6];
auto x266 = V{0.0185185185185185}*(x156 + x215 + x252 + x255 + x256)*(x180 + x224 + x261 + x264 + x265) + V{0.0185185185185185}*cell[20] + V{0.0185185185185185}*cell[7];
auto x267 = x123 + x203;
auto x268 = x128 + x241;
auto x269 = x233 + x268;
auto x270 = -V{0.037037037037037}*cell[3];
auto x271 = x270 + x83;
auto x272 = x86 + x88;
auto x273 = -x249;
auto x274 = x248 + x250 + x273;
auto x275 = V{2}*cell[7];
auto x276 = V{2}*cell[20];
auto x277 = x275 - x276;
auto x278 = -x258;
auto x279 = x257 + x259 + x278;
auto x280 = V{9}*cell[7];
auto x281 = V{9}*cell[20];
auto x282 = x280 - x281;
auto x283 = x193 + x236;
auto x284 = x283 + V{0.0185185185185185}*(x161 + x218 + x255 + x274 + x277)*(x185 + x227 + x264 + x279 + x282) + V{0.0185185185185185}*cell[19] + V{0.0185185185185185}*cell[6];
auto x285 = -V{0.037037037037037}*cell[7];
auto x286 = x128 + x285;
auto x287 = -V{0.037037037037037}*cell[5];
auto x288 = x231 + x287;
auto x289 = -V{0.0925925925925926}*cell[13] + V{0.12962962962963}*cell[26];
auto x290 = x244 + x289;
auto x291 = x113 + x118;
auto x292 = -V{2}*cell[21] + V{2}*cell[8];
auto x293 = x164 - x253 + x254;
auto x294 = -V{9}*cell[21] + V{9}*cell[8];
auto x295 = x188 - x262 + x263;
auto x296 = V{0.0185185185185185}*cell[1];
auto x297 = x193 + x296;
auto x298 = V{0.0185185185185185}*cell[14];
auto x299 = x197 + x298;
auto x300 = x202 + x297 + x299 + V{0.0185185185185185}*(x142 - x143 + x145 + x146 + x153 + x155 - x216 + x217 + x252 + x292 + x293)*(x166 - x167 + x169 + x170 + x177 + x179 - x225 + x226 + x261 + x294 + x295) + V{0.0185185185185185}*cell[22] + V{0.0185185185185185}*cell[9];
auto x301 = -V{0.037037037037037}*cell[6];
auto x302 = x122 + x301;
auto x303 = -V{0.0925925925925926}*cell[12] + V{0.12962962962963}*cell[25];
auto x304 = x135 + x303 + x79;
auto x305 = V{2}*cell[9];
auto x306 = V{2}*cell[22];
auto x307 = x305 - x306;
auto x308 = V{9}*cell[9];
auto x309 = V{9}*cell[22];
auto x310 = x308 - x309;
auto x311 = x233 + x296;
auto x312 = x203 + x298 + x311 + V{0.0185185185185185}*(-x142 + x143 + x144 + x147 + x158 + x160 - x213 + x214 + x274 + x293 + x307)*(-x166 + x167 + x168 + x171 + x182 + x184 - x222 + x223 + x279 + x295 + x310) + V{0.0185185185185185}*cell[21] + V{0.0185185185185185}*cell[8];
auto x313 = V{1}*cell[11];
auto x314 = V{1}*cell[12];
auto x315 = V{1}*cell[26];
auto x316 = V{1}*cell[13];
auto x317 = V{1}*cell[24];
auto x318 = V{1}*cell[25];
auto x319 = x150 + x165;
auto x320 = x251 + x292;
auto x321 = V{4.5}*cell[11];
auto x322 = V{4.5}*cell[12];
auto x323 = V{4.5}*cell[26];
auto x324 = V{4.5}*cell[13];
auto x325 = V{4.5}*cell[24];
auto x326 = V{4.5}*cell[25];
auto x327 = x174 + x189;
auto x328 = x260 + x294;
auto x329 = V{0.00462962962962963}*(x256 + x313 + x314 + x315 - x316 - x317 - x318 + x319 + x320 + V{3}*cell[10] - V{3}*cell[23])*(x265 + x321 + x322 + x323 - x324 - x325 - x326 + x327 + x328 + V{13.5}*cell[10] - V{13.5}*cell[23]);
auto x330 = V{0.00462962962962963}*cell[0];
auto x331 = V{0.00462962962962963}*cell[9];
auto x332 = V{0.00462962962962963}*cell[22];
auto x333 = -V{0.00925925925925926}*cell[14];
auto x334 = -V{0.00925925925925926}*cell[24];
auto x335 = -V{0.00925925925925926}*cell[25];
auto x336 = -V{0.00694444444444444}*x34;
auto x337 = -V{0.00694444444444444}*x38;
auto x338 = -V{0.00694444444444444}*x41;
auto x339 = x330 + x331 + x332 + x333 + x334 + x335 + x336 + x337 + x338;
auto x340 = V{0.00462962962962963}*cell[5];
auto x341 = V{0.00462962962962963}*cell[18];
auto x342 = -V{0.00925925925925926}*cell[13];
auto x343 = -V{0.00925925925925926}*cell[16];
auto x344 = x340 + x341 + x342 + x343;
auto x345 = V{0.00462962962962963}*cell[7];
auto x346 = V{0.00462962962962963}*cell[20];
auto x347 = -V{0.00925925925925926}*cell[15];
auto x348 = x345 + x346 + x347;
auto x349 = -V{0.0231481481481481}*cell[17] + V{0.0324074074074074}*cell[4];
auto x350 = -V{0.0231481481481481}*cell[19] + V{0.0324074074074074}*cell[6];
auto x351 = -V{0.0231481481481481}*cell[21] + V{0.0324074074074074}*cell[8];
auto x352 = V{1}*cell[10];
auto x353 = -V{1}*cell[23];
auto x354 = -x315 + x316 + x352 + x353;
auto x355 = -x314 + x318;
auto x356 = V{4.5}*cell[10];
auto x357 = -V{4.5}*cell[23];
auto x358 = -x323 + x324 + x356 + x357;
auto x359 = -x322 + x326;
auto x360 = V{0.00462962962962963}*(x250 + x273 + x277 + x307 + x319 + x354 + x355 + V{3}*cell[11] - V{3}*cell[24])*(x259 + x278 + x282 + x310 + x327 + x358 + x359 + V{13.5}*cell[11] - V{13.5}*cell[24]);
auto x361 = V{0.00462962962962963}*cell[6];
auto x362 = V{0.00462962962962963}*cell[19];
auto x363 = -V{0.00925925925925926}*cell[3];
auto x364 = x296 + x361 + x362 + x363 - V{0.0231481481481481}*cell[20] + V{0.0324074074074074}*cell[7];
auto x365 = V{0.00462962962962963}*cell[8];
auto x366 = V{0.00462962962962963}*cell[21];
auto x367 = -V{0.00925925925925926}*cell[23];
auto x368 = -V{0.00925925925925926}*cell[26];
auto x369 = x330 + x333 + x336 + x337 + x338 + x365 + x366 + x367 + x368;
auto x370 = -V{0.0231481481481481}*cell[22] + V{0.0324074074074074}*cell[9];
auto x371 = -V{0.00925925925925926}*cell[12];
auto x372 = x347 + x371;
auto x373 = x191 + x340 + x341;
auto x374 = -V{0.00925925925925926}*cell[2];
auto x375 = x374 + V{0.0324074074074074}*cell[22] - V{0.0231481481481481}*cell[9];
auto x376 = V{0.00462962962962963}*cell[4];
auto x377 = V{0.00462962962962963}*cell[17];
auto x378 = -x313 + x317;
auto x379 = -x321 + x325;
auto x380 = x376 + x377 + V{0.00462962962962963}*(x150 + x221 + x251 + x256 - x305 + x306 + x354 + x378 + V{3}*cell[12] - V{3}*cell[25])*(x174 + x230 + x260 + x265 - x308 + x309 + x358 + x379 + V{13.5}*cell[12] - V{13.5}*cell[25]);
auto x381 = -V{0.00925925925925926}*cell[11];
auto x382 = x343 + x381;
auto x383 = -V{0.0231481481481481}*cell[18] + V{0.0324074074074074}*cell[5];
auto x384 = x237 + x345 + x346;
auto x385 = x201 - V{0.00925925925925926}*cell[10];
auto x386 = x374 + V{0.0324074074074074}*cell[21] - V{0.0231481481481481}*cell[8];
auto x387 = x376 + x377 + V{0.00462962962962963}*(-x148 + x149 + x164 - x219 + x220 - x275 + x276 + x320 + x352 + x353 + x355 + x378 - V{3}*cell[13] + V{3}*cell[26])*(-x172 + x173 + x188 - x228 + x229 - x280 + x281 + x328 + x356 + x357 + x359 + x379 - V{13.5}*cell[13] + V{13.5}*cell[26]);
auto x388 = -V{0.148148148148148}*cell[10];
auto x389 = x388 + x59 + x72 - V{0.148148148148148}*cell[4];
auto x390 = x54 + x75 - V{0.148148148148148}*cell[6];
auto x391 = x49 + x63 + x69 + x95 - V{0.148148148148148}*cell[8];
auto x392 = -V{0.0925925925925926}*cell[10] + V{0.12962962962963}*cell[23];
auto x393 = -V{0.0925925925925926}*cell[11] + V{0.12962962962963}*cell[24];
auto x394 = -V{0.037037037037037}*cell[1];
auto x395 = x101 + x106 + x394;
auto x396 = -V{0.037037037037037}*cell[4];
auto x397 = x191 + x396;
auto x398 = x270 + x392;
auto x399 = x119 + x241 + x394;
auto x400 = x393 + x80;
auto x401 = x114 + x117 + x205;
auto x402 = -V{0.00925925925925926}*cell[1];
auto x403 = x330 + x331 + x332 + x336 + x337 + x338 + x402;
auto x404 = x298 + V{0.0324074074074074}*cell[17] - V{0.0231481481481481}*cell[4];
auto x405 = x194 + x363 + V{0.0324074074074074}*cell[19] - V{0.0231481481481481}*cell[6];
auto x406 = x190 + x361 + x362 + V{0.0324074074074074}*cell[20] - V{0.0231481481481481}*cell[7];
auto x407 = x330 + x336 + x337 + x338 + x365 + x366 + x385 + x402;
auto x408 = V{0.0324074074074074}*cell[18] - V{0.0231481481481481}*cell[5];
auto x409 = x32 + x36 + x39 + cell[0] + cell[11] + cell[12] + cell[14] + cell[15] + cell[16] + cell[17] + cell[19] + cell[21] + cell[23] + cell[26] + cell[4] + cell[6] + cell[8] + V{1};
auto x0 = x30*(x27 - V{0.444444444444444}*x34 - V{0.444444444444444}*x38 - V{0.444444444444444}*x41 + x50 + x56 + x60 + x64 + x66 + V{0.296296296296296}*cell[0]) - x67*cell[0];
auto x1 = x30*(x50 + x68 + x73 + x76 + x78 + x91 - V{0.148148148148148}*cell[14]) - x67*cell[1];
auto x2 = x30*(x108 + x42 + x56 + x73 + x94 + x96 + x97 - V{0.148148148148148}*cell[15]) - x67*cell[2];
auto x3 = x30*(x110 + x111 + x120 + x44 + x51 + x60 + x70 + x76 + x93 + x96 - V{0.148148148148148}*cell[16]) - x67*cell[3];
auto x4 = x30*(x112 + x127 + x130 + x134 + x137 + x140 + x141 + x196 + x87 - V{0.0925925925925926}*cell[17] + V{0.12962962962963}*cell[4]) - x67*cell[4];
auto x5 = x30*(x141 + x199 + x204 + x206 + x209 + x210 + x212 + x235 - V{0.0925925925925926}*cell[18] + V{0.12962962962963}*cell[5]) - x67*cell[5];
auto x6 = x30*(x115 + x129 + x134 + x211 + x237 + x239 + x240 + x243 + x246 + x247 + x266 + x99 - V{0.0925925925925926}*cell[19] + V{0.12962962962963}*cell[6]) - x67*cell[6];
auto x7 = x30*(x115 + x139 + x198 + x207 + x208 + x210 + x238 + x245 + x267 + x269 + x271 + x272 + x284 - V{0.0925925925925926}*cell[20] + V{0.12962962962963}*cell[7]) - x67*cell[7];
auto x8 = x30*(x102 + x131 + x133 + x137 + x238 + x286 + x288 + x290 + x291 + x300 + x81 - V{0.0925925925925926}*cell[21] + V{0.12962962962963}*cell[8]) - x67*cell[8];
auto x9 = x30*(x107 + x140 + x239 + x271 + x287 + x291 + x302 + x304 + x312 - V{0.0925925925925926}*cell[22] + V{0.12962962962963}*cell[9]) - x67*cell[9];
auto x10 = x30*(x232 + x242 + x297 + x329 + x339 + x344 + x348 + x349 + x350 + x351 + V{0.0462962962962963}*cell[10] - V{0.037037037037037}*cell[23]) - x67*cell[10];
auto x11 = x30*(x234 + x268 + x349 + x360 + x364 + x369 + x370 + x372 + x373 + V{0.0462962962962963}*cell[11] - V{0.037037037037037}*cell[24]) - x67*cell[11];
auto x12 = x30*(x192 + x311 + x350 + x369 + x375 + x380 + x382 + x383 + x384 + V{0.0462962962962963}*cell[12] - V{0.037037037037037}*cell[25]) - x67*cell[12];
auto x13 = x30*(x195 + x231 + x236 + x339 + x364 + x383 + x385 + x386 + x387 + V{0.0462962962962963}*cell[13] - V{0.037037037037037}*cell[26]) - x67*cell[13];
auto x14 = x30*(x110 + x389 + x390 + x53 + x57 + x64 + x91 + x94 - V{0.148148148148148}*cell[1]) - x67*cell[14];
auto x15 = x30*(x108 + x109 + x111 + x389 + x391 + x43 + x58 + x61 + x66 + x74 + x78 - V{0.148148148148148}*cell[2]) - x67*cell[15];
auto x16 = x30*(x120 + x27 + x388 + x390 + x391 + x45 + x52 + x62 + x65 + x68 + x71 + x77 + x92 + x97 - V{0.148148148148148}*cell[3]) - x67*cell[16];
auto x17 = x30*(x116 + x196 + x198 + x206 + x240 + x286 + x302 + x392 + x393 + x395 + V{0.12962962962963}*cell[17] - V{0.0925925925925926}*cell[4]) - x67*cell[17];
auto x18 = x30*(x103 + x129 + x197 + x235 + x267 + x285 + x289 + x301 + x304 + x395 + x87 + V{0.12962962962963}*cell[18] - V{0.0925925925925926}*cell[5]) - x67*cell[18];
auto x19 = x30*(x104 + x127 + x199 + x236 + x266 + x272 + x288 + x303 + x397 + x398 + x399 + V{0.12962962962963}*cell[19] - V{0.0925925925925926}*cell[6]) - x67*cell[19];
auto x20 = x30*(x103 + x130 + x204 + x233 + x247 + x284 + x287 + x290 + x396 + x399 + x400 + V{0.12962962962963}*cell[20] - V{0.0925925925925926}*cell[7]) - x67*cell[20];
auto x21 = x30*(x107 + x128 + x209 + x231 + x245 + x300 + x301 + x396 + x398 + x401 + x84 + V{0.12962962962963}*cell[21] - V{0.0925925925925926}*cell[8]) - x67*cell[21];
auto x22 = x30*(x102 + x122 + x212 + x246 + x285 + x312 + x397 + x400 + x401 + V{0.12962962962963}*cell[22] - V{0.0925925925925926}*cell[9]) - x67*cell[22];
auto x23 = x30*(x128 + x329 + x368 + x371 + x373 + x381 + x384 + x386 + x403 + x404 + x405 - V{0.037037037037037}*cell[10] + V{0.0462962962962963}*cell[23]) - x67*cell[23];
auto x24 = x30*(x122 + x283 + x335 + x344 + x360 + x375 + x404 + x406 + x407 - V{0.037037037037037}*cell[11] + V{0.0462962962962963}*cell[24]) - x67*cell[24];
auto x25 = x30*(x243 + x298 + x334 + x342 + x348 + x370 + x380 + x405 + x407 + x408 - V{0.037037037037037}*cell[12] + V{0.0462962962962963}*cell[25]) - x67*cell[25];
auto x26 = x30*(x269 + x299 + x351 + x367 + x372 + x382 + x387 + x403 + x406 + x408 - V{0.037037037037037}*cell[13] + V{0.0462962962962963}*cell[26]) - x67*cell[26];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
cell[19] = x19;
cell[20] = x20;
cell[21] = x21;
cell[22] = x22;
cell[23] = x23;
cell[24] = x24;
cell[25] = x25;
cell[26] = x26;
return { x409, V{1}*(x34 + x38 + x41)/((x409)*(x409)) };
}
 
};
 
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D2Q5<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x8 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x7 = parameters.template get<olb::descriptors::OMEGA>();
auto x5 = x7 + V{-1};
auto x6 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4];
auto x9 = x6 + V{1};
auto x10 = V{1} / ((x9)*(x9));
auto x11 = V{1.5}*x10;
auto x12 = cell[2] - cell[4];
auto x13 = -x12;
auto x14 = x13*x13;
auto x15 = cell[1] - cell[3];
auto x16 = -x15;
auto x17 = x11*(x16*x16) + V{-1};
auto x18 = x11*x14 + x17;
auto x19 = V{1} / (x9);
auto x20 = -x19*(x8 + V{-1}) + V{1};
auto x21 = x6 + V{1};
auto x22 = x20*x21;
auto x23 = V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667};
auto x24 = x19*(V{3}*cell[1] - V{3}*cell[3]);
auto x25 = V{3}*x10;
auto x26 = x15*x15;
auto x27 = x12*x12;
auto x28 = x11*x27;
auto x29 = x24 + x25*x26 - x28 + V{1};
auto x30 = V{3}*cell[2] - V{3}*cell[4];
auto x31 = -x14*x25 + x17 - x19*x30;
auto x32 = V{3}*x10*x26 - x24 - x28 + V{1};
auto x33 = V{3}*x10*x27 - x11*x26 - x19*x30 + V{1};
auto x0 = -V{0.333333333333333}*x18*x22 - x5*(x18*(V{0.333333333333333}*cell[0] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}) + cell[0] + V{0.333333333333333}) + V{-0.333333333333333};
auto x1 = V{0.166666666666667}*x20*x21*x29 - x5*(-x23*x29 + cell[1] + V{0.166666666666667}) + V{-0.166666666666667};
auto x2 = -V{0.166666666666667}*x22*x31 - x5*(x23*x31 + cell[2] + V{0.166666666666667}) + V{-0.166666666666667};
auto x3 = V{0.166666666666667}*x20*x21*x32 - x5*(-x23*x32 + cell[3] + V{0.166666666666667}) + V{-0.166666666666667};
auto x4 = V{0.166666666666667}*x20*x21*x33 - x5*(-x23*x33 + cell[4] + V{0.166666666666667}) + V{-0.166666666666667};
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
return { x6 - x8 + V{2}, V{1}*x10*(x26 + x27) };
}
 
};
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::descriptors::OMEGA>();
auto x12 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x9 = x11 + V{-1};
auto x10 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8];
auto x13 = x10 + V{1};
auto x14 = V{1} / ((x13)*(x13));
auto x15 = V{1.5}*x14;
auto x16 = cell[1] - cell[5];
auto x17 = -cell[4] + cell[8];
auto x18 = x16 + x17 - cell[3] + cell[7];
auto x19 = x18*x18;
auto x20 = x15*x19;
auto x21 = cell[2] - cell[6];
auto x22 = x16 + x21 + cell[3] - cell[7];
auto x23 = -x22;
auto x24 = x15*(x23*x23) + V{-1};
auto x25 = x20 + x24;
auto x26 = V{1} / (x13);
auto x27 = -x26*(x12 + V{-1}) + V{1};
auto x28 = x10 + V{1};
auto x29 = x27*x28;
auto x30 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778};
auto x31 = V{4.5}*x14;
auto x32 = x17 + x21 + V{2}*cell[1] - V{2}*cell[5];
auto x33 = -x32;
auto x34 = V{3}*cell[3];
auto x35 = V{3}*cell[7];
auto x36 = V{3}*cell[1] - V{3}*cell[5];
auto x37 = x34 - x35 + x36 + V{3}*cell[2] - V{3}*cell[6];
auto x38 = x26*x37;
auto x39 = -x20 + x38 + V{1};
auto x40 = x26*(-x34 + x35 + x36 - V{3}*cell[4] + V{3}*cell[8]);
auto x41 = x22*x22;
auto x42 = x15*x41;
auto x43 = x40 - x42;
auto x44 = x31*(x33*x33) + x39 + x43;
auto x45 = V{0.111111111111111}*cell[0] + V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[2] + V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[4] + V{0.111111111111111}*cell[5] + V{0.111111111111111}*cell[6] + V{0.111111111111111}*cell[7] + V{0.111111111111111}*cell[8] + V{0.111111111111111};
auto x46 = V{3}*x14;
auto x47 = x39 + x41*x46;
auto x48 = -x21 - V{2}*cell[3] - cell[4] + V{2}*cell[7] + cell[8];
auto x49 = -x31*x48*x48;
auto x50 = x25 - x26*x37 + x40 + x49;
auto x51 = x19*x46;
auto x52 = x24 + x40 - x51;
auto x53 = x20 + x38 + V{-1};
auto x54 = x42 + x53;
auto x55 = V{4.5}*x14*(x32*x32) - x40 - x54;
auto x56 = V{3}*x14*x41 - x53;
auto x57 = x40 - x49 - x54;
auto x58 = x43 + x51 + V{1};
auto x0 = -V{0.444444444444444}*x25*x29 - x9*(x25*(V{0.444444444444444}*cell[0] + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444}) + cell[0] + V{0.444444444444444}) + V{-0.444444444444444};
auto x1 = V{0.0277777777777778}*x27*x28*x44 - x9*(-x30*x44 + cell[1] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x2 = V{0.111111111111111}*x27*x28*x47 - x9*(-x45*x47 + cell[2] + V{0.111111111111111}) + V{-0.111111111111111};
auto x3 = -V{0.0277777777777778}*x29*x50 - x9*(x30*x50 + cell[3] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x4 = -V{0.111111111111111}*x29*x52 - x9*(x45*x52 + cell[4] + V{0.111111111111111}) + V{-0.111111111111111};
auto x5 = V{0.0277777777777778}*x27*x28*x55 - x9*(-x30*x55 + cell[5] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x6 = V{0.111111111111111}*x27*x28*x56 - x9*(-x45*x56 + cell[6] + V{0.111111111111111}) + V{-0.111111111111111};
auto x7 = V{0.0277777777777778}*x27*x28*x57 - x9*(-x30*x57 + cell[7] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x8 = V{0.111111111111111}*x27*x28*x58 - x9*(-x45*x58 + cell[8] + V{0.111111111111111}) + V{-0.111111111111111};
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
return { x10 - x12 + V{2}, V{1}*x14*(x19 + x41) };
}
 
};
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D3Q7<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x10 = parameters.template get<olb::descriptors::OMEGA>();
auto x7 = x10 + V{-1};
auto x8 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6];
auto x9 = x8 + V{1};
auto x12 = V{1} / ((x9)*(x9));
auto x13 = V{2}*x12;
auto x14 = cell[1] - cell[4];
auto x15 = -x14;
auto x16 = x15*x15;
auto x17 = x13*x16;
auto x18 = cell[2] - cell[5];
auto x19 = -x18;
auto x20 = x19*x19;
auto x21 = x13*x20;
auto x22 = cell[3] - cell[6];
auto x23 = -x22;
auto x24 = x23*x23;
auto x25 = x13*x24;
auto x26 = x21 + x25 + V{-1};
auto x27 = x17 + x26;
auto x28 = V{1} / (x9);
auto x29 = -x28*(x11 + V{-1}) + V{1};
auto x30 = x8 + V{1};
auto x31 = x29*x30;
auto x32 = V{0.125}*cell[0] + V{0.125}*cell[1] + V{0.125}*cell[2] + V{0.125}*cell[3] + V{0.125}*cell[4] + V{0.125}*cell[5] + V{0.125}*cell[6] + V{0.125};
auto x33 = V{4}*cell[1] - V{4}*cell[4];
auto x34 = V{6}*x12;
auto x35 = -x16*x34 + x26 - x28*x33;
auto x36 = V{0.125}*x31;
auto x37 = V{4}*cell[2] - V{4}*cell[5];
auto x38 = x17 + V{-1};
auto x39 = -x20*x34 + x25 - x28*x37 + x38;
auto x40 = V{4}*cell[3] - V{4}*cell[6];
auto x41 = x21 - x24*x34 - x28*x40 + x38;
auto x42 = x18*x18;
auto x43 = x13*x42;
auto x44 = x14*x14;
auto x45 = x22*x22;
auto x46 = x13*x45 + V{-1};
auto x47 = V{6}*x12*x44 - x28*x33 - x43 - x46;
auto x48 = x13*x44;
auto x49 = V{6}*x12*x42 - x28*x37 - x46 - x48;
auto x50 = V{6}*x12*x45 - x28*x40 - x43 - x48 + V{1};
auto x0 = -V{0.25}*x27*x31 - x7*(x27*(V{0.25}*cell[0] + V{0.25}*cell[1] + V{0.25}*cell[2] + V{0.25}*cell[3] + V{0.25}*cell[4] + V{0.25}*cell[5] + V{0.25}*cell[6] + V{0.25}) + cell[0] + V{0.25}) + V{-0.25};
auto x1 = -x35*x36 - x7*(x32*x35 + cell[1] + V{0.125}) + V{-0.125};
auto x2 = -x36*x39 - x7*(x32*x39 + cell[2] + V{0.125}) + V{-0.125};
auto x3 = -x36*x41 - x7*(x32*x41 + cell[3] + V{0.125}) + V{-0.125};
auto x4 = V{0.125}*x29*x30*x47 - x7*(-x32*x47 + cell[4] + V{0.125}) + V{-0.125};
auto x5 = V{0.125}*x29*x30*x49 - x7*(-x32*x49 + cell[5] + V{0.125}) + V{-0.125};
auto x6 = V{0.125}*x29*x30*x50 - x7*(-x32*x50 + cell[6] + V{0.125}) + V{-0.125};
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
return { -x11 + x8 + V{2}, V{1}*x12*(x42 + x44 + x45) };
}
 
};
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x23 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x19 = x22 + V{-1};
auto x20 = cell[10] + cell[14];
auto x21 = cell[12] + cell[7];
auto x24 = x20 + x21 + cell[0] + cell[11] + cell[13] + cell[15] + cell[16] + cell[17] + cell[18] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + cell[9];
auto x25 = x24 + V{1};
auto x26 = V{1} / ((x25)*(x25));
auto x27 = V{1.5}*x26;
auto x28 = cell[13] - cell[4];
auto x29 = cell[15] - cell[6];
auto x30 = x28 + x29;
auto x31 = -cell[1];
auto x32 = cell[16] - cell[7];
auto x33 = x31 + x32;
auto x34 = x20 - cell[5];
auto x35 = x30 + x33 + x34;
auto x36 = x35*x35;
auto x37 = x27*x36;
auto x38 = cell[17] - cell[8];
auto x39 = x28 + x38;
auto x40 = cell[18] - cell[9];
auto x41 = -cell[2];
auto x42 = x41 + cell[11] - cell[14] + cell[5];
auto x43 = x39 + x40 + x42;
auto x44 = x43*x43;
auto x45 = x27*x44;
auto x46 = x29 + x38;
auto x47 = -cell[3];
auto x48 = -cell[18] + cell[9];
auto x49 = x47 + x48;
auto x50 = x21 - cell[16];
auto x51 = x46 + x49 + x50;
auto x52 = x51*x51;
auto x53 = x27*x52;
auto x54 = x45 + x53 + V{-1};
auto x55 = x37 + x54;
auto x56 = V{1} / (x25);
auto x57 = -x56*(x23 + V{-1}) + V{1};
auto x58 = x24 + V{1};
auto x59 = x57*x58;
auto x60 = V{0.0555555555555556}*cell[0] + V{0.0555555555555556}*cell[10] + V{0.0555555555555556}*cell[11] + V{0.0555555555555556}*cell[12] + V{0.0555555555555556}*cell[13] + V{0.0555555555555556}*cell[14] + V{0.0555555555555556}*cell[15] + V{0.0555555555555556}*cell[16] + V{0.0555555555555556}*cell[17] + V{0.0555555555555556}*cell[18] + V{0.0555555555555556}*cell[1] + V{0.0555555555555556}*cell[2] + V{0.0555555555555556}*cell[3] + V{0.0555555555555556}*cell[4] + V{0.0555555555555556}*cell[5] + V{0.0555555555555556}*cell[6] + V{0.0555555555555556}*cell[7] + V{0.0555555555555556}*cell[8] + V{0.0555555555555556}*cell[9] + V{0.0555555555555556};
auto x61 = V{3}*cell[14];
auto x62 = V{3}*cell[16];
auto x63 = V{3}*cell[5];
auto x64 = V{3}*cell[7];
auto x65 = V{3}*cell[13] - V{3}*cell[4];
auto x66 = V{3}*cell[15] - V{3}*cell[6];
auto x67 = x56*(x61 + x62 - x63 - x64 + x65 + x66 + V{3}*cell[10] - V{3}*cell[1]);
auto x68 = V{3}*x26;
auto x69 = x36*x68;
auto x70 = x54 + x67 - x69;
auto x71 = V{0.0555555555555556}*x59;
auto x72 = V{3}*cell[18];
auto x73 = V{3}*cell[9];
auto x74 = V{3}*cell[17] - V{3}*cell[8];
auto x75 = x56*(-x61 + x63 + x65 + x72 - x73 + x74 + V{3}*cell[11] - V{3}*cell[2]);
auto x76 = x44*x68;
auto x77 = x37 + V{-1};
auto x78 = x53 + x75 - x76 + x77;
auto x79 = x56*(-x62 + x64 + x66 - x72 + x73 + x74 + V{3}*cell[12] - V{3}*cell[3]);
auto x80 = x52*x68;
auto x81 = x45 + x77 + x79 - x80;
auto x82 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778};
auto x83 = V{4.5}*x26;
auto x84 = x33 + cell[10];
auto x85 = x40 + x41 + x46 + x84 + cell[11] + V{2}*cell[13] - V{2}*cell[4];
auto x86 = x83*(x85*x85);
auto x87 = x55 + x67;
auto x88 = x75 - x86 + x87;
auto x89 = V{0.0277777777777778}*x59;
auto x90 = -x75;
auto x91 = -cell[17] + cell[8];
auto x92 = x29 + x48 + x84 + x91 - cell[11] + V{2}*cell[14] + cell[2] - V{2}*cell[5];
auto x93 = -x92;
auto x94 = -x83*x93*x93 + x87 + x90;
auto x95 = x31 + x34;
auto x96 = x39 + x49 + x95 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x97 = x83*(x96*x96);
auto x98 = x79 + x87 - x97;
auto x99 = -x79;
auto x100 = x28 - cell[12] + cell[3];
auto x101 = x100 + x40 + x91 + x95 + V{2}*cell[16] - V{2}*cell[7];
auto x102 = -x101;
auto x103 = -x83*x102*x102 + x87 + x99;
auto x104 = x30 + x42 + x47 + x50 + V{2}*cell[17] - V{2}*cell[8];
auto x105 = x83*(x104*x104);
auto x106 = x55 + x75;
auto x107 = -x105 + x106 + x79;
auto x108 = x100 + x32 + x42 - cell[15] + V{2}*cell[18] + cell[6] - V{2}*cell[9];
auto x109 = -x108;
auto x110 = x106 - x83*x109*x109 + x99;
auto x111 = -x45;
auto x112 = V{1} - x53;
auto x113 = x111 + x112;
auto x114 = x113 + x67;
auto x115 = x114 + x69;
auto x116 = -x37;
auto x117 = x116 + x75;
auto x118 = x112 + x117 + x76;
auto x119 = x116 + x79;
auto x120 = x111 + x119 + x80 + V{1};
auto x121 = x114 + x117 + x86;
auto x122 = -x67;
auto x123 = x106 + x122 - x83*x92*x92;
auto x124 = x114 + x119 + x97;
auto x125 = x55 + x79;
auto x126 = x122 + x125 - x83*x101*x101;
auto x127 = x105 + x113 + x117 + x79;
auto x128 = x125 - x83*x108*x108 + x90;
auto x0 = -x19*(x55*(V{0.333333333333333}*cell[0] + V{0.333333333333333}*cell[10] + V{0.333333333333333}*cell[11] + V{0.333333333333333}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9] + V{0.333333333333333}) + cell[0] + V{0.333333333333333}) - V{0.333333333333333}*x55*x59 + V{-0.333333333333333};
auto x1 = -x19*(x60*x70 + cell[1] + V{0.0555555555555556}) - x70*x71 + V{-0.0555555555555556};
auto x2 = -x19*(x60*x78 + cell[2] + V{0.0555555555555556}) - x71*x78 + V{-0.0555555555555556};
auto x3 = -x19*(x60*x81 + cell[3] + V{0.0555555555555556}) - x71*x81 + V{-0.0555555555555556};
auto x4 = -x19*(x82*x88 + cell[4] + V{0.0277777777777778}) - x88*x89 + V{-0.0277777777777778};
auto x5 = -x19*(x82*x94 + cell[5] + V{0.0277777777777778}) - x89*x94 + V{-0.0277777777777778};
auto x6 = -x19*(x82*x98 + cell[6] + V{0.0277777777777778}) - x89*x98 + V{-0.0277777777777778};
auto x7 = -x103*x89 - x19*(x103*x82 + cell[7] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x8 = -x107*x89 - x19*(x107*x82 + cell[8] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x9 = -x110*x89 - x19*(x110*x82 + cell[9] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x10 = V{0.0555555555555556}*x115*x57*x58 - x19*(-x115*x60 + cell[10] + V{0.0555555555555556}) + V{-0.0555555555555556};
auto x11 = V{0.0555555555555556}*x118*x57*x58 - x19*(-x118*x60 + cell[11] + V{0.0555555555555556}) + V{-0.0555555555555556};
auto x12 = V{0.0555555555555556}*x120*x57*x58 - x19*(-x120*x60 + cell[12] + V{0.0555555555555556}) + V{-0.0555555555555556};
auto x13 = V{0.0277777777777778}*x121*x57*x58 - x19*(-x121*x82 + cell[13] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x14 = -x123*x89 - x19*(x123*x82 + cell[14] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x15 = V{0.0277777777777778}*x124*x57*x58 - x19*(-x124*x82 + cell[15] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x16 = -x126*x89 - x19*(x126*x82 + cell[16] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x17 = V{0.0277777777777778}*x127*x57*x58 - x19*(-x127*x82 + cell[17] + V{0.0277777777777778}) + V{-0.0277777777777778};
auto x18 = -x128*x89 - x19*(x128*x82 + cell[18] + V{0.0277777777777778}) + V{-0.0277777777777778};
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { -x23 + x24 + V{2}, V{1}*x26*(x36 + x44 + x52) };
}
 
};
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x31 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x30 = parameters.template get<olb::descriptors::OMEGA>();
auto x27 = x30 + V{-1};
auto x28 = cell[8] + cell[9];
auto x29 = cell[15] + cell[21];
auto x32 = cell[11] + cell[26];
auto x33 = x28 + x29 + x32 + cell[0] + cell[10] + cell[12] + cell[13] + cell[14] + cell[16] + cell[17] + cell[18] + cell[19] + cell[1] + cell[20] + cell[22] + cell[23] + cell[24] + cell[25] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7];
auto x34 = x33 + V{1};
auto x35 = V{1} / ((x34)*(x34));
auto x36 = V{1.5}*x35;
auto x37 = -cell[17];
auto x38 = -cell[19];
auto x39 = x37 + x38 + cell[4] + cell[6];
auto x40 = -cell[24];
auto x41 = cell[10] - cell[23];
auto x42 = x40 + x41 + cell[11];
auto x43 = cell[12] - cell[25];
auto x44 = -cell[14];
auto x45 = -cell[20] + cell[7];
auto x46 = x44 + x45 + cell[1];
auto x47 = -cell[18] + cell[5];
auto x48 = cell[13] - cell[26];
auto x49 = x39 + x42 + x43 + x46 + x47 + x48;
auto x50 = -x49;
auto x51 = x50*x50;
auto x52 = x36*x51;
auto x53 = -cell[13];
auto x54 = -cell[21];
auto x55 = x53 + x54 + cell[26] + cell[8];
auto x56 = -cell[22];
auto x57 = x37 + cell[4];
auto x58 = x56 + x57 + cell[9];
auto x59 = -cell[15];
auto x60 = x59 + cell[18] + cell[2] - cell[5];
auto x61 = -cell[12] + cell[25];
auto x62 = x42 + x55 + x58 + x60 + x61;
auto x63 = -x62;
auto x64 = x63*x63;
auto x65 = x36*x64;
auto x66 = -cell[16];
auto x67 = x43 + x66 + cell[3];
auto x68 = -cell[9];
auto x69 = x38 + cell[6];
auto x70 = x68 + x69 + cell[22];
auto x71 = cell[20] - cell[7];
auto x72 = x41 - cell[11] + cell[24];
auto x73 = x55 + x67 + x70 + x71 + x72;
auto x74 = -x73;
auto x75 = x74*x74;
auto x76 = x36*x75;
auto x77 = x65 + x76 + V{-1};
auto x78 = x52 + x77;
auto x79 = V{1} / (x34);
auto x80 = -x79*(x31 + V{-1}) + V{1};
auto x81 = x33 + V{1};
auto x82 = x80*x81;
auto x83 = V{0.0740740740740741}*cell[0] + V{0.0740740740740741}*cell[10] + V{0.0740740740740741}*cell[11] + V{0.0740740740740741}*cell[12] + V{0.0740740740740741}*cell[13] + V{0.0740740740740741}*cell[14] + V{0.0740740740740741}*cell[15] + V{0.0740740740740741}*cell[16] + V{0.0740740740740741}*cell[17] + V{0.0740740740740741}*cell[18] + V{0.0740740740740741}*cell[19] + V{0.0740740740740741}*cell[1] + V{0.0740740740740741}*cell[20] + V{0.0740740740740741}*cell[21] + V{0.0740740740740741}*cell[22] + V{0.0740740740740741}*cell[23] + V{0.0740740740740741}*cell[24] + V{0.0740740740740741}*cell[25] + V{0.0740740740740741}*cell[26] + V{0.0740740740740741}*cell[2] + V{0.0740740740740741}*cell[3] + V{0.0740740740740741}*cell[4] + V{0.0740740740740741}*cell[5] + V{0.0740740740740741}*cell[6] + V{0.0740740740740741}*cell[7] + V{0.0740740740740741}*cell[8] + V{0.0740740740740741}*cell[9] + V{0.0740740740740741};
auto x84 = V{3}*cell[5];
auto x85 = V{3}*cell[7];
auto x86 = V{3}*cell[13];
auto x87 = V{3}*cell[18];
auto x88 = V{3}*cell[20];
auto x89 = V{3}*cell[26];
auto x90 = V{3}*cell[10];
auto x91 = V{3}*cell[11];
auto x92 = -V{3}*cell[23];
auto x93 = V{3}*cell[24];
auto x94 = x90 + x91 + x92 - x93 - V{3}*cell[17] + V{3}*cell[4];
auto x95 = V{3}*cell[12];
auto x96 = V{3}*cell[25];
auto x97 = x95 - x96 - V{3}*cell[19] + V{3}*cell[6];
auto x98 = x84 + x85 + x86 - x87 - x88 - x89 + x94 + x97 - V{3}*cell[14] + V{3}*cell[1];
auto x99 = -x79*x98;
auto x100 = V{3}*x35;
auto x101 = -x100*x51 + x77 + x99;
auto x102 = V{0.0740740740740741}*x82;
auto x103 = V{3}*cell[9];
auto x104 = V{3}*cell[22];
auto x105 = -x86 + x89 - V{3}*cell[21] + V{3}*cell[8];
auto x106 = x103 - x104 + x105 - x84 + x87 + x94 - x95 + x96 - V{3}*cell[15] + V{3}*cell[2];
auto x107 = -x106*x79;
auto x108 = x52 + V{-1};
auto x109 = -x100*x64 + x107 + x108 + x76;
auto x110 = -x103 + x104 + x105 - x85 + x88 + x90 - x91 + x92 + x93 + x97 - V{3}*cell[16] + V{3}*cell[3];
auto x111 = -x110*x79;
auto x112 = -x100*x75 + x108 + x111 + x65;
auto x113 = V{0.0185185185185185}*cell[0] + V{0.0185185185185185}*cell[10] + V{0.0185185185185185}*cell[11] + V{0.0185185185185185}*cell[12] + V{0.0185185185185185}*cell[13] + V{0.0185185185185185}*cell[14] + V{0.0185185185185185}*cell[15] + V{0.0185185185185185}*cell[16] + V{0.0185185185185185}*cell[17] + V{0.0185185185185185}*cell[18] + V{0.0185185185185185}*cell[19] + V{0.0185185185185185}*cell[1] + V{0.0185185185185185}*cell[20] + V{0.0185185185185185}*cell[21] + V{0.0185185185185185}*cell[22] + V{0.0185185185185185}*cell[23] + V{0.0185185185185185}*cell[24] + V{0.0185185185185185}*cell[25] + V{0.0185185185185185}*cell[26] + V{0.0185185185185185}*cell[2] + V{0.0185185185185185}*cell[3] + V{0.0185185185185185}*cell[4] + V{0.0185185185185185}*cell[5] + V{0.0185185185185185}*cell[6] + V{0.0185185185185185}*cell[7] + V{0.0185185185185185}*cell[8] + V{0.0185185185185185}*cell[9] + V{0.0185185185185185};
auto x114 = V{4.5}*x35;
auto x115 = V{2}*cell[11] - V{2}*cell[24];
auto x116 = V{2}*cell[10] - V{2}*cell[23];
auto x117 = x116 + x54;
auto x118 = x59 + cell[2];
auto x119 = x118 - V{2}*cell[17] + V{2}*cell[4];
auto x120 = x115 + x117 + x119 + x28 + x46 + x56 + x69;
auto x121 = -x120;
auto x122 = x78 + x99;
auto x123 = x107 + x122;
auto x124 = -x114*x121*x121 + x123;
auto x125 = V{0.0185185185185185}*x82;
auto x126 = V{2}*cell[25];
auto x127 = V{2}*cell[12];
auto x128 = -x126 + x127;
auto x129 = V{2}*cell[26];
auto x130 = V{2}*cell[13];
auto x131 = -x129 + x130 - cell[8];
auto x132 = V{2}*cell[18];
auto x133 = V{2}*cell[5];
auto x134 = -x132 + x133 - cell[2];
auto x135 = x128 + x131 + x134 + x29 + x46 + x70;
auto x136 = -x107;
auto x137 = x122 + x136;
auto x138 = -x114*x135*x135 + x137;
auto x139 = x44 + cell[1];
auto x140 = x139 + x47;
auto x141 = x66 + cell[3];
auto x142 = -V{2}*cell[19] + V{2}*cell[6];
auto x143 = x141 + x142;
auto x144 = x117 + x128 + x140 + x143 + x57 + x68 + cell[22] + cell[8];
auto x145 = -x144;
auto x146 = x111 - x114*x145*x145 + x122;
auto x147 = -x111;
auto x148 = -cell[3];
auto x149 = x115 + x148 + cell[16];
auto x150 = V{2}*cell[20];
auto x151 = V{2}*cell[7];
auto x152 = -x150 + x151;
auto x153 = x131 + x140 + x149 + x152 + x58 + cell[21];
auto x154 = -x114*x153*x153 + x122 + x147;
auto x155 = -V{2}*cell[21] + V{2}*cell[8];
auto x156 = x141 + x155;
auto x157 = x116 + x129 - x130 + x156 + x39 + x60 + x71;
auto x158 = -x157;
auto x159 = x107 + x78;
auto x160 = x111 + x159;
auto x161 = -x114*x158*x158 + x160;
auto x162 = V{2}*cell[22];
auto x163 = V{2}*cell[9];
auto x164 = -x162 + x163;
auto x165 = x126 - x127 + x149 + x164 + x45 + x57 + x60 + cell[19] - cell[6];
auto x166 = -x114*x165*x165 + x147 + x159;
auto x167 = V{0.00462962962962963}*cell[0] + V{0.00462962962962963}*cell[10] + V{0.00462962962962963}*cell[11] + V{0.00462962962962963}*cell[12] + V{0.00462962962962963}*cell[13] + V{0.00462962962962963}*cell[14] + V{0.00462962962962963}*cell[15] + V{0.00462962962962963}*cell[16] + V{0.00462962962962963}*cell[17] + V{0.00462962962962963}*cell[18] + V{0.00462962962962963}*cell[19] + V{0.00462962962962963}*cell[1] + V{0.00462962962962963}*cell[20] + V{0.00462962962962963}*cell[21] + V{0.00462962962962963}*cell[22] + V{0.00462962962962963}*cell[23] + V{0.00462962962962963}*cell[24] + V{0.00462962962962963}*cell[25] + V{0.00462962962962963}*cell[26] + V{0.00462962962962963}*cell[2] + V{0.00462962962962963}*cell[3] + V{0.00462962962962963}*cell[4] + V{0.00462962962962963}*cell[5] + V{0.00462962962962963}*cell[6] + V{0.00462962962962963}*cell[7] + V{0.00462962962962963}*cell[8] + V{0.00462962962962963}*cell[9] + V{0.00462962962962963};
auto x168 = x119 + x139;
auto x169 = x142 + x155 + x168 + x32 + x40 + x53 + x67 + V{3}*cell[10] - V{3}*cell[23];
auto x170 = -x169;
auto x171 = x111 - x114*x170*x170 + x123;
auto x172 = V{0.00462962962962963}*x82;
auto x173 = x148 + x152 + x164 + x168 + x41 + x48 + x61 + V{3}*cell[11] + cell[16] - V{3}*cell[24];
auto x174 = -x114*x173*x173 + x123 + x147;
auto x175 = x134 + x139 + x143 + x162 - x163 + x48 + x72 + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x176 = x111 - x114*x175*x175 + x137;
auto x177 = x79*x98;
auto x178 = x118 + x132 - x133 + x150 - x151 + x156 + x61 + x72 - V{3}*cell[13] + cell[14] - cell[1] + V{3}*cell[26];
auto x179 = -x178;
auto x180 = x110*x79;
auto x181 = x62*x62;
auto x182 = x181*x36;
auto x183 = x73*x73;
auto x184 = x183*x36 + V{-1};
auto x185 = x182 + x184;
auto x186 = x106*x79;
auto x187 = x49*x49;
auto x188 = x187*x36;
auto x189 = x186 + x188;
auto x190 = x180 + x185 + x189;
auto x191 = x177 - x190 + V{4.5}*x35*(x179*x179);
auto x192 = x177 + x185;
auto x193 = V{3}*x187*x35 - x192;
auto x194 = V{3}*x181*x35 - x184 - x189;
auto x195 = x180 + x188;
auto x196 = -x182 + V{3}*x183*x35 - x195 + V{1};
auto x197 = x189 + x192;
auto x198 = -x197 + V{4.5}*x35*(x120*x120);
auto x199 = -x99;
auto x200 = -x135;
auto x201 = -x114*x200*x200 + x159 + x199;
auto x202 = x192 + x195;
auto x203 = -x202 + V{4.5}*x35*(x144*x144);
auto x204 = -x153;
auto x205 = x111 + x78;
auto x206 = -x114*x204*x204 + x199 + x205;
auto x207 = -x190 + V{4.5}*x35*(x157*x157);
auto x208 = -x165;
auto x209 = -x114*x208*x208 + x136 + x205;
auto x210 = -x180 - x197 + V{4.5}*x35*(x169*x169);
auto x211 = -x173;
auto x212 = x180 - x197 + V{4.5}*x35*(x211*x211);
auto x213 = -x175;
auto x214 = x186 - x202 + V{4.5}*x35*(x213*x213);
auto x215 = -x114*x178*x178 + x160 + x199;
auto x0 = -x27*(x78*(V{0.296296296296296}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9] + V{0.296296296296296}) + cell[0] + V{0.296296296296296}) - V{0.296296296296296}*x78*x82 + V{-0.296296296296296};
auto x1 = -x101*x102 - x27*(x101*x83 + cell[1] + V{0.0740740740740741}) + V{-0.0740740740740741};
auto x2 = -x102*x109 - x27*(x109*x83 + cell[2] + V{0.0740740740740741}) + V{-0.0740740740740741};
auto x3 = -x102*x112 - x27*(x112*x83 + cell[3] + V{0.0740740740740741}) + V{-0.0740740740740741};
auto x4 = -x124*x125 - x27*(x113*x124 + cell[4] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x5 = -x125*x138 - x27*(x113*x138 + cell[5] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x6 = -x125*x146 - x27*(x113*x146 + cell[6] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x7 = -x125*x154 - x27*(x113*x154 + cell[7] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x8 = -x125*x161 - x27*(x113*x161 + cell[8] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x9 = -x125*x166 - x27*(x113*x166 + cell[9] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x10 = -x171*x172 - x27*(x167*x171 + cell[10] + V{0.00462962962962963}) + V{-0.00462962962962963};
auto x11 = -x172*x174 - x27*(x167*x174 + cell[11] + V{0.00462962962962963}) + V{-0.00462962962962963};
auto x12 = -x172*x176 - x27*(x167*x176 + cell[12] + V{0.00462962962962963}) + V{-0.00462962962962963};
auto x13 = V{0.00462962962962963}*x191*x80*x81 - x27*(-x167*x191 + cell[13] + V{0.00462962962962963}) + V{-0.00462962962962963};
auto x14 = V{0.0740740740740741}*x193*x80*x81 - x27*(-x193*x83 + cell[14] + V{0.0740740740740741}) + V{-0.0740740740740741};
auto x15 = V{0.0740740740740741}*x194*x80*x81 - x27*(-x194*x83 + cell[15] + V{0.0740740740740741}) + V{-0.0740740740740741};
auto x16 = V{0.0740740740740741}*x196*x80*x81 - x27*(-x196*x83 + cell[16] + V{0.0740740740740741}) + V{-0.0740740740740741};
auto x17 = V{0.0185185185185185}*x198*x80*x81 - x27*(-x113*x198 + cell[17] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x18 = -x125*x201 - x27*(x113*x201 + cell[18] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x19 = V{0.0185185185185185}*x203*x80*x81 - x27*(-x113*x203 + cell[19] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x20 = -x125*x206 - x27*(x113*x206 + cell[20] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x21 = V{0.0185185185185185}*x207*x80*x81 - x27*(-x113*x207 + cell[21] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x22 = -x125*x209 - x27*(x113*x209 + cell[22] + V{0.0185185185185185}) + V{-0.0185185185185185};
auto x23 = V{0.00462962962962963}*x210*x80*x81 - x27*(-x167*x210 + cell[23] + V{0.00462962962962963}) + V{-0.00462962962962963};
auto x24 = V{0.00462962962962963}*x212*x80*x81 - x27*(-x167*x212 + cell[24] + V{0.00462962962962963}) + V{-0.00462962962962963};
auto x25 = V{0.00462962962962963}*x214*x80*x81 - x27*(-x167*x214 + cell[25] + V{0.00462962962962963}) + V{-0.00462962962962963};
auto x26 = -x172*x215 - x27*(x167*x215 + cell[26] + V{0.00462962962962963}) + V{-0.00462962962962963};
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
cell[19] = x19;
cell[20] = x20;
cell[21] = x21;
cell[22] = x22;
cell[23] = x23;
cell[24] = x24;
cell[25] = x25;
cell[26] = x26;
return { -x31 + x33 + V{2}, V{1}*x35*(x181 + x183 + x187) };
}
 
};
 
 
template <typename... FIELDS>
struct RLB::type<descriptors::D2Q5<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x7 = parameters.template get<olb::descriptors::OMEGA>();
auto x5 = x7 + V{-1};
auto x6 = V{0.333333333333333}*cell[0];
auto x8 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + V{1};
auto x9 = V{1} / (x8);
auto x10 = V{0.5}*x9;
auto x11 = cell[1] - cell[3];
auto x12 = -x11;
auto x13 = x12*x12;
auto x14 = cell[2] - cell[4];
auto x15 = -x14;
auto x16 = x15*x15;
auto x17 = x10*x16;
auto x18 = V{1} / ((x8)*(x8));
auto x19 = V{1.5}*x18;
auto x20 = x13*x19 + V{-1};
auto x21 = V{0.166666666666667}*cell[0] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4] + V{0.166666666666667};
auto x22 = x9*(V{3}*cell[1] - V{3}*cell[3]);
auto x23 = V{3}*x18;
auto x24 = x11*x11;
auto x25 = x14*x14;
auto x26 = x19*x25;
auto x27 = V{0.0833333333333333}*cell[0];
auto x28 = V{0.25}*x9;
auto x29 = x5*(x10*x24 - x25*x28 + x27 - V{0.416666666666667}*cell[1] + V{0.333333333333333}*cell[2] - V{0.416666666666667}*cell[3] + V{0.333333333333333}*cell[4]) + V{-0.166666666666667};
auto x30 = x27 + V{0.333333333333333}*cell[1] - V{0.416666666666667}*cell[2] + V{0.333333333333333}*cell[3] - V{0.416666666666667}*cell[4];
auto x31 = V{3}*cell[2] - V{3}*cell[4];
auto x0 = x5*(-x10*x13 - x17 - x6 + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[4]) - (x16*x19 + x20)*(x6 + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}) + V{-0.333333333333333};
auto x1 = x21*(x22 + x23*x24 - x26 + V{1}) + x29;
auto x2 = -x21*(-x16*x23 + x20 - x31*x9) + x5*(-x13*x28 + x17 + x30) + V{-0.166666666666667};
auto x3 = x21*(V{3}*x18*x24 - x22 - x26 + V{1}) + x29;
auto x4 = -x21*(x19*x24 - x23*x25 + x31*x9 + V{-1}) + x5*(x10*x25 - x24*x28 + x30) + V{-0.166666666666667};
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
return { x8, V{1}*x18*(x24 + x25) };
}
 
};
 
template <typename... FIELDS>
struct RLB::type<descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::descriptors::OMEGA>();
auto x9 = x11 + V{-1};
auto x10 = V{0.444444444444444}*cell[0];
auto x12 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8];
auto x13 = x12 + V{1};
auto x14 = V{1} / (x13);
auto x15 = V{0.666666666666667}*x14;
auto x16 = cell[1] - cell[5];
auto x17 = cell[2] - cell[6];
auto x18 = x16 + x17 + cell[3] - cell[7];
auto x19 = -x18;
auto x20 = x19*x19;
auto x21 = -cell[4] + cell[8];
auto x22 = x16 + x21 - cell[3] + cell[7];
auto x23 = x22*x22;
auto x24 = V{1} / ((x13)*(x13));
auto x25 = V{1.5}*x24;
auto x26 = x23*x25;
auto x27 = x20*x25 + V{-1};
auto x28 = x26 + x27;
auto x29 = x12 + V{1};
auto x30 = V{4.5}*x24;
auto x31 = x17 + x21 + V{2}*cell[1] - V{2}*cell[5];
auto x32 = -x31;
auto x33 = V{3}*cell[3];
auto x34 = V{3}*cell[7];
auto x35 = V{3}*cell[1] - V{3}*cell[5];
auto x36 = x33 - x34 + x35 + V{3}*cell[2] - V{3}*cell[6];
auto x37 = x14*x36;
auto x38 = -x26 + x37 + V{1};
auto x39 = x14*(-x33 + x34 + x35 - V{3}*cell[4] + V{3}*cell[8]);
auto x40 = x18*x18;
auto x41 = x25*x40;
auto x42 = x39 - x41;
auto x43 = V{0.0833333333333333}*x14;
auto x44 = x40*x43;
auto x45 = V{0.25}*x14*x22;
auto x46 = x18*x45;
auto x47 = V{0.0555555555555556}*cell[0];
auto x48 = V{0.0277777777777778}*cell[2];
auto x49 = V{0.0277777777777778}*cell[4];
auto x50 = V{0.0277777777777778}*cell[6];
auto x51 = V{0.0277777777777778}*cell[8];
auto x52 = x23*x43;
auto x53 = x47 - x48 - x49 - x50 - x51 + x52;
auto x54 = x9*(-x44 - x46 - x53 + V{0.361111111111111}*cell[1] - V{0.138888888888889}*cell[3] + V{0.361111111111111}*cell[5] - V{0.138888888888889}*cell[7]) + V{0.0277777777777778};
auto x55 = V{3}*x24;
auto x56 = V{0.166666666666667}*x14;
auto x57 = V{0.333333333333333}*x14;
auto x58 = -V{0.0555555555555556}*cell[0] + V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[5] + V{0.111111111111111}*cell[7];
auto x59 = x9*(x23*x56 - x40*x57 + x58 + V{0.277777777777778}*cell[2] - V{0.222222222222222}*cell[4] + V{0.277777777777778}*cell[6] - V{0.222222222222222}*cell[8]) + V{0.111111111111111};
auto x60 = V{0.361111111111111}*cell[3];
auto x61 = V{0.361111111111111}*cell[7];
auto x62 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778};
auto x63 = x17 + V{2}*cell[3] + cell[4] - V{2}*cell[7] - cell[8];
auto x64 = -x63;
auto x65 = x23*x55;
auto x66 = x9*(-x23*x57 + x40*x56 + x58 - V{0.222222222222222}*cell[2] + V{0.277777777777778}*cell[4] - V{0.222222222222222}*cell[6] + V{0.277777777777778}*cell[8]) + V{0.111111111111111};
auto x67 = x26 + x37 + V{-1};
auto x68 = x41 + x67;
auto x0 = -x28*(x10 + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444}) + x9*(-x10 - x15*x20 - x15*x23 + V{0.888888888888889}*cell[1] + V{0.222222222222222}*cell[2] + V{0.888888888888889}*cell[3] + V{0.222222222222222}*cell[4] + V{0.888888888888889}*cell[5] + V{0.222222222222222}*cell[6] + V{0.888888888888889}*cell[7] + V{0.222222222222222}*cell[8]) + V{-0.444444444444444};
auto x1 = V{0.0277777777777778}*x29*(x30*(x32*x32) + x38 + x42) - x54;
auto x2 = V{0.111111111111111}*x29*(x38 + x40*x55) - x59;
auto x3 = -x62*(-x14*x36 + x28 - x30*x64*x64 + x39) + x9*(x19*x45 + x20*x43 + x53 - x60 - x61 + V{0.138888888888889}*cell[1] + V{0.138888888888889}*cell[5]) + V{-0.0277777777777778};
auto x4 = -x66 - (x27 + x39 - x65)*(V{0.111111111111111}*cell[0] + V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[2] + V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[4] + V{0.111111111111111}*cell[5] + V{0.111111111111111}*cell[6] + V{0.111111111111111}*cell[7] + V{0.111111111111111}*cell[8] + V{0.111111111111111});
auto x5 = -V{0.0277777777777778}*x29*(-V{4.5}*x24*x31*x31 + x39 + x68) - x54;
auto x6 = V{0.111111111111111}*x29*(V{3}*x24*x40 - x67) - x59;
auto x7 = -x62*(-V{4.5}*x24*x63*x63 - x39 + x68) + x9*(x44 - x46 + x47 - x48 - x49 - x50 - x51 + x52 - x60 - x61 + V{0.138888888888889}*cell[1] + V{0.138888888888889}*cell[5]) + V{-0.0277777777777778};
auto x8 = V{0.111111111111111}*x29*(x42 + x65 + V{1}) - x66;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
return { x13, V{1}*x24*(x23 + x40) };
}
 
};
 
template <typename... FIELDS>
struct RLB::type<descriptors::D3Q7<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x10 = parameters.template get<olb::descriptors::OMEGA>();
auto x7 = x10 + V{-1};
auto x8 = V{0.125}*cell[1];
auto x9 = V{0.125}*cell[2];
auto x11 = V{0.125}*cell[3];
auto x12 = V{0.125}*cell[4];
auto x13 = V{0.125}*cell[5];
auto x14 = V{0.125}*cell[6];
auto x15 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + V{1};
auto x16 = V{1} / (x15);
auto x17 = V{0.5}*x16;
auto x18 = cell[1] - cell[4];
auto x19 = -x18;
auto x20 = x19*x19;
auto x21 = cell[2] - cell[5];
auto x22 = -x21;
auto x23 = x22*x22;
auto x24 = cell[3] - cell[6];
auto x25 = -x24;
auto x26 = x25*x25;
auto x27 = V{1} / ((x15)*(x15));
auto x28 = V{2}*x27;
auto x29 = x20*x28;
auto x30 = x23*x28;
auto x31 = x26*x28;
auto x32 = x30 + x31 + V{-1};
auto x33 = V{0.75}*x16;
auto x34 = V{0.25}*x16;
auto x35 = V{0.0625}*cell[0];
auto x36 = x35 + V{0.3125}*cell[3] + V{0.3125}*cell[6];
auto x37 = -x26*x34 + x36;
auto x38 = V{0.3125}*cell[2] + V{0.3125}*cell[5];
auto x39 = -x23*x34 + x38;
auto x40 = -V{0.6875}*cell[1] - V{0.6875}*cell[4];
auto x41 = x11 + x12 + x13 + x14 + x8 + x9 + V{0.125}*cell[0] + V{0.125};
auto x42 = V{4}*cell[1] - V{4}*cell[4];
auto x43 = V{6}*x27;
auto x44 = V{0.3125}*cell[1] + V{0.3125}*cell[4];
auto x45 = -x20*x34 + x44;
auto x46 = -V{0.6875}*cell[2] - V{0.6875}*cell[5];
auto x47 = V{4}*cell[2] - V{4}*cell[5];
auto x48 = x29 + V{-1};
auto x49 = x35 - V{0.6875}*cell[3] - V{0.6875}*cell[6];
auto x50 = V{4}*cell[3] - V{4}*cell[6];
auto x51 = x18*x18;
auto x52 = x24*x24;
auto x53 = -x34*x52 + x36;
auto x54 = x21*x21;
auto x55 = -x34*x54 + x38;
auto x56 = x28*x54;
auto x57 = x28*x52 + V{-1};
auto x58 = -x34*x51 + x44;
auto x59 = x28*x51;
auto x0 = x7*(x11 + x12 + x13 + x14 - x17*x20 - x17*x23 - x17*x26 + x8 + x9 - V{0.375}*cell[0]) - (x29 + x32)*(V{0.25}*cell[0] + V{0.25}*cell[1] + V{0.25}*cell[2] + V{0.25}*cell[3] + V{0.25}*cell[4] + V{0.25}*cell[5] + V{0.25}*cell[6] + V{0.25}) + V{-0.25};
auto x1 = -x41*(-x16*x42 - x20*x43 + x32) + x7*(x20*x33 + x37 + x39 + x40) + V{-0.125};
auto x2 = -x41*(-x16*x47 - x23*x43 + x31 + x48) + x7*(x23*x33 + x37 + x45 + x46) + V{-0.125};
auto x3 = -x41*(-x16*x50 - x26*x43 + x30 + x48) + x7*(x26*x33 + x39 + x45 + x49) + V{-0.125};
auto x4 = -x41*(x16*x42 - x43*x51 + x56 + x57) + x7*(x33*x51 + x40 + x53 + x55) + V{-0.125};
auto x5 = -x41*(x16*x47 - x43*x54 + x57 + x59) + x7*(x33*x54 + x46 + x53 + x58) + V{-0.125};
auto x6 = -x41*(x16*x50 - x43*x52 + x56 + x59 + V{-1}) + x7*(x33*x52 + x49 + x55 + x58) + V{-0.125};
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
return { x15, V{1}*x27*(x51 + x52 + x54) };
}
 
};
 
template <typename... FIELDS>
struct RLB::type<descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x19 = x22 + V{-1};
auto x20 = cell[10] + cell[14];
auto x21 = cell[12] + cell[7];
auto x23 = x20 + x21 + cell[0] + cell[11] + cell[13] + cell[15] + cell[16] + cell[17] + cell[18] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + cell[9];
auto x24 = x23 + V{1};
auto x25 = V{1} / (x24);
auto x26 = V{0.5}*x25;
auto x27 = cell[13] - cell[4];
auto x28 = cell[15] - cell[6];
auto x29 = x27 + x28;
auto x30 = -cell[1];
auto x31 = cell[16] - cell[7];
auto x32 = x30 + x31;
auto x33 = x20 - cell[5];
auto x34 = x29 + x32 + x33;
auto x35 = x34*x34;
auto x36 = cell[17] - cell[8];
auto x37 = x27 + x36;
auto x38 = cell[18] - cell[9];
auto x39 = -cell[2];
auto x40 = x39 + cell[11] - cell[14] + cell[5];
auto x41 = x37 + x38 + x40;
auto x42 = x41*x41;
auto x43 = x28 + x36;
auto x44 = -cell[3];
auto x45 = -cell[18] + cell[9];
auto x46 = x44 + x45;
auto x47 = x21 - cell[16];
auto x48 = x43 + x46 + x47;
auto x49 = x48*x48;
auto x50 = V{1} / ((x24)*(x24));
auto x51 = V{1.5}*x50;
auto x52 = x35*x51;
auto x53 = x42*x51;
auto x54 = x49*x51;
auto x55 = x53 + x54 + V{-1};
auto x56 = x52 + x55;
auto x57 = V{0.0555555555555556}*cell[0] + V{0.0555555555555556}*cell[10] + V{0.0555555555555556}*cell[11] + V{0.0555555555555556}*cell[12] + V{0.0555555555555556}*cell[13] + V{0.0555555555555556}*cell[14] + V{0.0555555555555556}*cell[15] + V{0.0555555555555556}*cell[16] + V{0.0555555555555556}*cell[17] + V{0.0555555555555556}*cell[18] + V{0.0555555555555556}*cell[1] + V{0.0555555555555556}*cell[2] + V{0.0555555555555556}*cell[3] + V{0.0555555555555556}*cell[4] + V{0.0555555555555556}*cell[5] + V{0.0555555555555556}*cell[6] + V{0.0555555555555556}*cell[7] + V{0.0555555555555556}*cell[8] + V{0.0555555555555556}*cell[9] + V{0.0555555555555556};
auto x58 = V{3}*cell[14];
auto x59 = V{3}*cell[16];
auto x60 = V{3}*cell[5];
auto x61 = V{3}*cell[7];
auto x62 = V{3}*cell[13] - V{3}*cell[4];
auto x63 = V{3}*cell[15] - V{3}*cell[6];
auto x64 = x25*(x58 + x59 - x60 - x61 + x62 + x63 + V{3}*cell[10] - V{3}*cell[1]);
auto x65 = V{3}*x50;
auto x66 = x35*x65;
auto x67 = V{0.166666666666667}*x25;
auto x68 = -V{6.93889390390723e-18}*cell[0];
auto x69 = V{0.0833333333333333}*x25;
auto x70 = -V{0.0833333333333333}*cell[12] - V{0.0833333333333333}*cell[3];
auto x71 = x49*x69 + x68 + x70 + V{0.0833333333333333}*cell[13] + V{0.0833333333333333}*cell[14] + V{0.0833333333333333}*cell[4] + V{0.0833333333333333}*cell[5];
auto x72 = -V{0.0833333333333333}*cell[11] - V{0.0833333333333333}*cell[2];
auto x73 = x42*x69 + x72 + V{0.0833333333333333}*cell[15] + V{0.0833333333333333}*cell[16] + V{0.0833333333333333}*cell[6] + V{0.0833333333333333}*cell[7];
auto x74 = x19*(-x35*x67 + x71 + x73 + V{0.166666666666667}*cell[10] - V{0.166666666666667}*cell[17] - V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[1] - V{0.166666666666667}*cell[8] - V{0.166666666666667}*cell[9]) + V{0.0555555555555556};
auto x75 = V{3}*cell[18];
auto x76 = V{3}*cell[9];
auto x77 = V{3}*cell[17] - V{3}*cell[8];
auto x78 = x25*(-x58 + x60 + x62 + x75 - x76 + x77 + V{3}*cell[11] - V{3}*cell[2]);
auto x79 = x42*x65;
auto x80 = x52 + V{-1};
auto x81 = -V{0.0833333333333333}*cell[10] - V{0.0833333333333333}*cell[1];
auto x82 = x35*x69 + x81 + V{0.0833333333333333}*cell[17] + V{0.0833333333333333}*cell[18] + V{0.0833333333333333}*cell[8] + V{0.0833333333333333}*cell[9];
auto x83 = x19*(-x42*x67 + x71 + x82 + V{0.166666666666667}*cell[11] - V{0.166666666666667}*cell[15] - V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[2] - V{0.166666666666667}*cell[6] - V{0.166666666666667}*cell[7]) + V{0.0555555555555556};
auto x84 = x25*(-x59 + x61 + x63 - x75 + x76 + x77 + V{3}*cell[12] - V{3}*cell[3]);
auto x85 = x49*x65;
auto x86 = x19*(-x49*x67 + x68 + x73 + x82 + V{0.166666666666667}*cell[12] - V{0.166666666666667}*cell[13] - V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[3] - V{0.166666666666667}*cell[4] - V{0.166666666666667}*cell[5]) + V{0.0555555555555556};
auto x87 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778};
auto x88 = V{4.5}*x50;
auto x89 = x32 + cell[10];
auto x90 = x38 + x39 + x43 + x89 + cell[11] + V{2}*cell[13] - V{2}*cell[4];
auto x91 = x88*(x90*x90);
auto x92 = x56 + x64;
auto x93 = V{0.25}*x25*x34;
auto x94 = x41*x93;
auto x95 = V{0.0416666666666667}*x25;
auto x96 = -V{0.0416666666666667}*cell[0];
auto x97 = V{0.0833333333333333}*x25;
auto x98 = -x35*x97 + x96 + V{0.0416666666666667}*cell[10] + V{6.93889390390723e-18}*cell[17] + V{6.93889390390723e-18}*cell[18] + V{0.0416666666666667}*cell[1] + V{6.93889390390723e-18}*cell[8] + V{6.93889390390723e-18}*cell[9];
auto x99 = -x42*x97 + V{0.0416666666666667}*cell[11] + V{6.93889390390723e-18}*cell[15] + V{6.93889390390723e-18}*cell[16] + V{0.0416666666666667}*cell[2] + V{6.93889390390723e-18}*cell[6] + V{6.93889390390723e-18}*cell[7];
auto x100 = x49*x95 + x70 + x98 + x99;
auto x101 = x19*(x100 - x94 + V{0.375}*cell[13] - V{0.125}*cell[14] + V{0.375}*cell[4] - V{0.125}*cell[5]) + V{0.0277777777777778};
auto x102 = -x78;
auto x103 = -cell[17] + cell[8];
auto x104 = x103 + x28 + x45 + x89 - cell[11] + V{2}*cell[14] + cell[2] - V{2}*cell[5];
auto x105 = -x104;
auto x106 = x19*(x100 + x94 - V{0.125}*cell[13] + V{0.375}*cell[14] - V{0.125}*cell[4] + V{0.375}*cell[5]) + V{0.0277777777777778};
auto x107 = x30 + x33;
auto x108 = x107 + x37 + x46 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x109 = x88*(x108*x108);
auto x110 = x48*x93;
auto x111 = -x49*x97 + V{0.0416666666666667}*cell[12] + V{6.93889390390723e-18}*cell[13] + V{6.93889390390723e-18}*cell[14] + V{0.0416666666666667}*cell[3] + V{6.93889390390723e-18}*cell[4] + V{6.93889390390723e-18}*cell[5];
auto x112 = x111 + x42*x95 + x72 + x98;
auto x113 = x19*(-x110 + x112 + V{0.375}*cell[15] - V{0.125}*cell[16] + V{0.375}*cell[6] - V{0.125}*cell[7]) + V{0.0277777777777778};
auto x114 = -x84;
auto x115 = x27 - cell[12] + cell[3];
auto x116 = x103 + x107 + x115 + x38 + V{2}*cell[16] - V{2}*cell[7];
auto x117 = -x116;
auto x118 = x19*(x110 + x112 - V{0.125}*cell[15] + V{0.375}*cell[16] - V{0.125}*cell[6] + V{0.375}*cell[7]) + V{0.0277777777777778};
auto x119 = x29 + x40 + x44 + x47 + V{2}*cell[17] - V{2}*cell[8];
auto x120 = x88*(x119*x119);
auto x121 = x56 + x78;
auto x122 = V{0.25}*x25*x41*x48;
auto x123 = x111 + x35*x95 + x81 + x96 + x99;
auto x124 = x19*(-x122 + x123 + V{0.375}*cell[17] - V{0.125}*cell[18] + V{0.375}*cell[8] - V{0.125}*cell[9]) + V{0.0277777777777778};
auto x125 = x115 + x31 + x40 - cell[15] + V{2}*cell[18] + cell[6] - V{2}*cell[9];
auto x126 = -x125;
auto x127 = x19*(x122 + x123 - V{0.125}*cell[17] + V{0.375}*cell[18] - V{0.125}*cell[8] + V{0.375}*cell[9]) + V{0.0277777777777778};
auto x128 = x23 + V{1};
auto x129 = -x53;
auto x130 = V{1} - x54;
auto x131 = x129 + x130;
auto x132 = x131 + x64;
auto x133 = -x52;
auto x134 = x133 + x78;
auto x135 = x133 + x84;
auto x136 = -x64;
auto x137 = x56 + x84;
auto x0 = x19*(-x26*x35 - x26*x42 - x26*x49 - V{0.5}*cell[0] + V{4.16333634234434e-17}*cell[10] + V{4.16333634234434e-17}*cell[11] + V{4.16333634234434e-17}*cell[12] + V{0.5}*cell[13] + V{0.5}*cell[14] + V{0.5}*cell[15] + V{0.5}*cell[16] + V{0.5}*cell[17] + V{0.5}*cell[18] + V{4.16333634234434e-17}*cell[1] + V{4.16333634234434e-17}*cell[2] + V{4.16333634234434e-17}*cell[3] + V{0.5}*cell[4] + V{0.5}*cell[5] + V{0.5}*cell[6] + V{0.5}*cell[7] + V{0.5}*cell[8] + V{0.5}*cell[9]) - x56*(V{0.333333333333333}*cell[0] + V{0.333333333333333}*cell[10] + V{0.333333333333333}*cell[11] + V{0.333333333333333}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9] + V{0.333333333333333}) + V{-0.333333333333333};
auto x1 = -x57*(x55 + x64 - x66) - x74;
auto x2 = -x57*(x54 + x78 - x79 + x80) - x83;
auto x3 = -x57*(x53 + x80 + x84 - x85) - x86;
auto x4 = -x101 - x87*(x78 - x91 + x92);
auto x5 = -x106 - x87*(x102 - x88*x105*x105 + x92);
auto x6 = -x113 - x87*(-x109 + x84 + x92);
auto x7 = -x118 - x87*(x114 - x88*x117*x117 + x92);
auto x8 = -x124 - x87*(-x120 + x121 + x84);
auto x9 = -x127 - x87*(x114 + x121 - x88*x126*x126);
auto x10 = V{0.0555555555555556}*x128*(x132 + x66) - x74;
auto x11 = V{0.0555555555555556}*x128*(x130 + x134 + x79) - x83;
auto x12 = V{0.0555555555555556}*x128*(x129 + x135 + x85 + V{1}) - x86;
auto x13 = -x101 + V{0.0277777777777778}*x128*(x132 + x134 + x91);
auto x14 = -x106 - x87*(x121 + x136 - x88*x104*x104);
auto x15 = -x113 + V{0.0277777777777778}*x128*(x109 + x132 + x135);
auto x16 = -x118 - x87*(x136 + x137 - x88*x116*x116);
auto x17 = -x124 + V{0.0277777777777778}*x128*(x120 + x131 + x134 + x84);
auto x18 = -x127 - x87*(x102 + x137 - x88*x125*x125);
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { x24, V{1}*x50*(x35 + x42 + x49) };
}
 
};
 
template <typename... FIELDS>
struct RLB::type<descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x30 = parameters.template get<olb::descriptors::OMEGA>();
auto x27 = x30 + V{-1};
auto x28 = cell[8] + cell[9];
auto x29 = cell[15] + cell[21];
auto x31 = cell[11] + cell[26];
auto x32 = x28 + x29 + x31 + cell[0] + cell[10] + cell[12] + cell[13] + cell[14] + cell[16] + cell[17] + cell[18] + cell[19] + cell[1] + cell[20] + cell[22] + cell[23] + cell[24] + cell[25] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7];
auto x33 = x32 + V{1};
auto x34 = V{1} / (x33);
auto x35 = V{0.444444444444444}*x34;
auto x36 = -cell[17];
auto x37 = -cell[19];
auto x38 = x36 + x37 + cell[4] + cell[6];
auto x39 = -cell[24];
auto x40 = cell[10] - cell[23];
auto x41 = x39 + x40 + cell[11];
auto x42 = cell[12] - cell[25];
auto x43 = -cell[14];
auto x44 = -cell[20] + cell[7];
auto x45 = x43 + x44 + cell[1];
auto x46 = -cell[18] + cell[5];
auto x47 = cell[13] - cell[26];
auto x48 = x38 + x41 + x42 + x45 + x46 + x47;
auto x49 = -x48;
auto x50 = x49*x49;
auto x51 = -cell[13];
auto x52 = -cell[21];
auto x53 = x51 + x52 + cell[26] + cell[8];
auto x54 = -cell[22];
auto x55 = x36 + cell[4];
auto x56 = x54 + x55 + cell[9];
auto x57 = -cell[15];
auto x58 = x57 + cell[18] + cell[2] - cell[5];
auto x59 = -cell[12] + cell[25];
auto x60 = x41 + x53 + x56 + x58 + x59;
auto x61 = -x60;
auto x62 = x61*x61;
auto x63 = -cell[16];
auto x64 = x42 + x63 + cell[3];
auto x65 = -cell[9];
auto x66 = x37 + cell[6];
auto x67 = x65 + x66 + cell[22];
auto x68 = cell[20] - cell[7];
auto x69 = x40 - cell[11] + cell[24];
auto x70 = x53 + x64 + x67 + x68 + x69;
auto x71 = -x70;
auto x72 = x71*x71;
auto x73 = V{1} / ((x33)*(x33));
auto x74 = V{1.5}*x73;
auto x75 = x50*x74;
auto x76 = x62*x74;
auto x77 = x72*x74;
auto x78 = x76 + x77 + V{-1};
auto x79 = x75 + x78;
auto x80 = V{0.0740740740740741}*cell[0] + V{0.0740740740740741}*cell[10] + V{0.0740740740740741}*cell[11] + V{0.0740740740740741}*cell[12] + V{0.0740740740740741}*cell[13] + V{0.0740740740740741}*cell[14] + V{0.0740740740740741}*cell[15] + V{0.0740740740740741}*cell[16] + V{0.0740740740740741}*cell[17] + V{0.0740740740740741}*cell[18] + V{0.0740740740740741}*cell[19] + V{0.0740740740740741}*cell[1] + V{0.0740740740740741}*cell[20] + V{0.0740740740740741}*cell[21] + V{0.0740740740740741}*cell[22] + V{0.0740740740740741}*cell[23] + V{0.0740740740740741}*cell[24] + V{0.0740740740740741}*cell[25] + V{0.0740740740740741}*cell[26] + V{0.0740740740740741}*cell[2] + V{0.0740740740740741}*cell[3] + V{0.0740740740740741}*cell[4] + V{0.0740740740740741}*cell[5] + V{0.0740740740740741}*cell[6] + V{0.0740740740740741}*cell[7] + V{0.0740740740740741}*cell[8] + V{0.0740740740740741}*cell[9] + V{0.0740740740740741};
auto x81 = V{3}*cell[5];
auto x82 = V{3}*cell[7];
auto x83 = V{3}*cell[13];
auto x84 = V{3}*cell[18];
auto x85 = V{3}*cell[20];
auto x86 = V{3}*cell[26];
auto x87 = V{3}*cell[10];
auto x88 = V{3}*cell[11];
auto x89 = -V{3}*cell[23];
auto x90 = V{3}*cell[24];
auto x91 = x87 + x88 + x89 - x90 - V{3}*cell[17] + V{3}*cell[4];
auto x92 = V{3}*cell[12];
auto x93 = V{3}*cell[25];
auto x94 = x92 - x93 - V{3}*cell[19] + V{3}*cell[6];
auto x95 = x81 + x82 + x83 - x84 - x85 - x86 + x91 + x94 - V{3}*cell[14] + V{3}*cell[1];
auto x96 = -x34*x95;
auto x97 = V{3}*x73;
auto x98 = V{0.222222222222222}*x34;
auto x99 = x48*x48;
auto x100 = V{1.85037170770859e-17}*cell[10];
auto x101 = V{1.85037170770859e-17}*cell[11];
auto x102 = V{1.85037170770859e-17}*cell[12];
auto x103 = V{1.85037170770859e-17}*cell[13];
auto x104 = V{1.85037170770859e-17}*cell[23];
auto x105 = V{1.85037170770859e-17}*cell[24];
auto x106 = V{1.85037170770859e-17}*cell[25];
auto x107 = V{1.85037170770859e-17}*cell[26];
auto x108 = -V{9.25185853854297e-18}*cell[0];
auto x109 = V{0.111111111111111}*x34;
auto x110 = x70*x70;
auto x111 = x100 + x101 + x102 + x103 + x104 + x105 + x106 + x107 + x108 + x109*x110 - V{0.111111111111111}*cell[16] + V{0.111111111111111}*cell[17] + V{0.111111111111111}*cell[18] - V{0.111111111111111}*cell[3] + V{0.111111111111111}*cell[4] + V{0.111111111111111}*cell[5];
auto x112 = x60*x60;
auto x113 = x109*x112 - V{0.111111111111111}*cell[15] + V{0.111111111111111}*cell[19] + V{0.111111111111111}*cell[20] - V{0.111111111111111}*cell[2] + V{0.111111111111111}*cell[6] + V{0.111111111111111}*cell[7];
auto x114 = x27*(x111 + x113 - x98*x99 + V{0.222222222222222}*cell[14] + V{0.222222222222222}*cell[1] - V{0.222222222222222}*cell[21] - V{0.222222222222222}*cell[22] - V{0.222222222222222}*cell[8] - V{0.222222222222222}*cell[9]) + V{0.0740740740740741};
auto x115 = V{3}*cell[9];
auto x116 = V{3}*cell[22];
auto x117 = -x83 + x86 - V{3}*cell[21] + V{3}*cell[8];
auto x118 = x115 - x116 + x117 - x81 + x84 + x91 - x92 + x93 - V{3}*cell[15] + V{3}*cell[2];
auto x119 = -x118*x34;
auto x120 = x75 + V{-1};
auto x121 = x109*x99 - V{0.111111111111111}*cell[14] - V{0.111111111111111}*cell[1] + V{0.111111111111111}*cell[21] + V{0.111111111111111}*cell[22] + V{0.111111111111111}*cell[8] + V{0.111111111111111}*cell[9];
auto x122 = x27*(x111 - x112*x98 + x121 + V{0.222222222222222}*cell[15] - V{0.222222222222222}*cell[19] - V{0.222222222222222}*cell[20] + V{0.222222222222222}*cell[2] - V{0.222222222222222}*cell[6] - V{0.222222222222222}*cell[7]) + V{0.0740740740740741};
auto x123 = -x115 + x116 + x117 - x82 + x85 + x87 - x88 + x89 + x90 + x94 - V{3}*cell[16] + V{3}*cell[3];
auto x124 = -x123*x34;
auto x125 = x27*(x100 + x101 + x102 + x103 + x104 + x105 + x106 + x107 + x108 - x110*x98 + x113 + x121 + V{0.222222222222222}*cell[16] - V{0.222222222222222}*cell[17] - V{0.222222222222222}*cell[18] + V{0.222222222222222}*cell[3] - V{0.222222222222222}*cell[4] - V{0.222222222222222}*cell[5]) + V{0.0740740740740741};
auto x126 = V{0.0185185185185185}*cell[0] + V{0.0185185185185185}*cell[10] + V{0.0185185185185185}*cell[11] + V{0.0185185185185185}*cell[12] + V{0.0185185185185185}*cell[13] + V{0.0185185185185185}*cell[14] + V{0.0185185185185185}*cell[15] + V{0.0185185185185185}*cell[16] + V{0.0185185185185185}*cell[17] + V{0.0185185185185185}*cell[18] + V{0.0185185185185185}*cell[19] + V{0.0185185185185185}*cell[1] + V{0.0185185185185185}*cell[20] + V{0.0185185185185185}*cell[21] + V{0.0185185185185185}*cell[22] + V{0.0185185185185185}*cell[23] + V{0.0185185185185185}*cell[24] + V{0.0185185185185185}*cell[25] + V{0.0185185185185185}*cell[26] + V{0.0185185185185185}*cell[2] + V{0.0185185185185185}*cell[3] + V{0.0185185185185185}*cell[4] + V{0.0185185185185185}*cell[5] + V{0.0185185185185185}*cell[6] + V{0.0185185185185185}*cell[7] + V{0.0185185185185185}*cell[8] + V{0.0185185185185185}*cell[9] + V{0.0185185185185185};
auto x127 = V{4.5}*x73;
auto x128 = V{2}*cell[11] - V{2}*cell[24];
auto x129 = V{2}*cell[10] - V{2}*cell[23];
auto x130 = x129 + x52;
auto x131 = x57 + cell[2];
auto x132 = x131 - V{2}*cell[17] + V{2}*cell[4];
auto x133 = x128 + x130 + x132 + x28 + x45 + x54 + x66;
auto x134 = -x133;
auto x135 = x79 + x96;
auto x136 = x119 + x135;
auto x137 = x34*x60;
auto x138 = V{0.166666666666667}*x48;
auto x139 = x137*x138;
auto x140 = V{4.62592926927149e-18}*cell[8];
auto x141 = V{4.62592926927149e-18}*cell[9];
auto x142 = V{4.62592926927149e-18}*cell[21];
auto x143 = V{4.62592926927149e-18}*cell[22];
auto x144 = V{0.0277777777777778}*cell[1];
auto x145 = V{0.0277777777777778}*cell[14];
auto x146 = V{0.222222222222222}*cell[10];
auto x147 = V{0.222222222222222}*cell[23];
auto x148 = -V{0.111111111111111}*cell[13];
auto x149 = -V{0.111111111111111}*cell[26];
auto x150 = -V{0.0277777777777778}*cell[0];
auto x151 = V{0.0555555555555556}*x34;
auto x152 = -x151*x99;
auto x153 = x140 + x141 + x142 + x143 + x144 + x145 + x146 + x147 + x148 + x149 + x150 + x152;
auto x154 = V{0.222222222222222}*cell[11];
auto x155 = V{0.222222222222222}*cell[24];
auto x156 = -V{0.111111111111111}*cell[12];
auto x157 = -V{0.111111111111111}*cell[25];
auto x158 = x154 + x155 + x156 + x157;
auto x159 = V{0.0277777777777778}*x34;
auto x160 = -x112*x151 + V{0.0277777777777778}*cell[15] + V{4.62592926927149e-18}*cell[19] + V{4.62592926927149e-18}*cell[20] + V{0.0277777777777778}*cell[2] + V{4.62592926927149e-18}*cell[6] + V{4.62592926927149e-18}*cell[7];
auto x161 = x110*x159 + x160 - V{0.0555555555555556}*cell[16] - V{0.0555555555555556}*cell[3];
auto x162 = x27*(-x139 + x153 + x158 + x161 + V{0.25}*cell[17] - V{0.0833333333333333}*cell[18] + V{0.25}*cell[4] - V{0.0833333333333333}*cell[5]) + V{0.0185185185185185};
auto x163 = V{2}*cell[25];
auto x164 = V{2}*cell[12];
auto x165 = -x163 + x164;
auto x166 = V{2}*cell[26];
auto x167 = V{2}*cell[13];
auto x168 = -x166 + x167 - cell[8];
auto x169 = V{2}*cell[18];
auto x170 = V{2}*cell[5];
auto x171 = -x169 + x170 - cell[2];
auto x172 = x165 + x168 + x171 + x29 + x45 + x67;
auto x173 = -x119;
auto x174 = x135 + x173;
auto x175 = V{0.222222222222222}*cell[12];
auto x176 = V{0.222222222222222}*cell[25];
auto x177 = -V{0.111111111111111}*cell[11];
auto x178 = -V{0.111111111111111}*cell[24];
auto x179 = x175 + x176 + x177 + x178;
auto x180 = x150 + V{0.222222222222222}*cell[13] + V{0.222222222222222}*cell[26];
auto x181 = -V{0.111111111111111}*cell[10] - V{0.111111111111111}*cell[23];
auto x182 = x140 + x141 + x142 + x143 + x144 + x145 + x152 + x180 + x181;
auto x183 = x27*(x139 + x161 + x179 + x182 - V{0.0833333333333333}*cell[17] + V{0.25}*cell[18] - V{0.0833333333333333}*cell[4] + V{0.25}*cell[5]) + V{0.0185185185185185};
auto x184 = x43 + cell[1];
auto x185 = x184 + x46;
auto x186 = x63 + cell[3];
auto x187 = -V{2}*cell[19] + V{2}*cell[6];
auto x188 = x186 + x187;
auto x189 = x130 + x165 + x185 + x188 + x55 + x65 + cell[22] + cell[8];
auto x190 = -x189;
auto x191 = x34*x70;
auto x192 = x138*x191;
auto x193 = -x110*x151 + V{0.0277777777777778}*cell[16] + V{4.62592926927149e-18}*cell[17] + V{4.62592926927149e-18}*cell[18] + V{0.0277777777777778}*cell[3] + V{4.62592926927149e-18}*cell[4] + V{4.62592926927149e-18}*cell[5];
auto x194 = x112*x159 + x193 - V{0.0555555555555556}*cell[15] - V{0.0555555555555556}*cell[2];
auto x195 = x27*(x153 + x179 - x192 + x194 + V{0.25}*cell[19] - V{0.0833333333333333}*cell[20] + V{0.25}*cell[6] - V{0.0833333333333333}*cell[7]) + V{0.0185185185185185};
auto x196 = -x124;
auto x197 = -cell[3];
auto x198 = x128 + x197 + cell[16];
auto x199 = V{2}*cell[20];
auto x200 = V{2}*cell[7];
auto x201 = -x199 + x200;
auto x202 = x168 + x185 + x198 + x201 + x56 + cell[21];
auto x203 = x27*(x158 + x182 + x192 + x194 - V{0.0833333333333333}*cell[19] + V{0.25}*cell[20] - V{0.0833333333333333}*cell[6] + V{0.25}*cell[7]) + V{0.0185185185185185};
auto x204 = -V{2}*cell[21] + V{2}*cell[8];
auto x205 = x186 + x204;
auto x206 = x129 + x166 - x167 + x205 + x38 + x58 + x68;
auto x207 = -x206;
auto x208 = x119 + x79;
auto x209 = x124 + x208;
auto x210 = x137*x70;
auto x211 = V{0.166666666666667}*x210;
auto x212 = x159*x99 + x160 + x193 - V{0.0555555555555556}*cell[14] - V{0.0555555555555556}*cell[1];
auto x213 = x27*(x146 + x147 + x156 + x157 + x177 + x178 + x180 - x211 + x212 + V{0.25}*cell[21] - V{0.0833333333333333}*cell[22] + V{0.25}*cell[8] - V{0.0833333333333333}*cell[9]) + V{0.0185185185185185};
auto x214 = V{2}*cell[22];
auto x215 = V{2}*cell[9];
auto x216 = -x214 + x215;
auto x217 = x163 - x164 + x198 + x216 + x44 + x55 + x58 + cell[19] - cell[6];
auto x218 = x27*(x148 + x149 + x150 + x154 + x155 + x175 + x176 + x181 + x211 + x212 - V{0.0833333333333333}*cell[21] + V{0.25}*cell[22] - V{0.0833333333333333}*cell[8] + V{0.25}*cell[9]) + V{0.0185185185185185};
auto x219 = V{0.0138888888888889}*x34;
auto x220 = x219*x50;
auto x221 = x219*x62;
auto x222 = x219*x72;
auto x223 = V{0.0416666666666667}*x34*x49;
auto x224 = x223*x61;
auto x225 = V{0.0138888888888889}*cell[13];
auto x226 = V{0.0138888888888889}*cell[26];
auto x227 = x225 + x226 - V{0.0555555555555556}*cell[17] + V{0.0277777777777778}*cell[18] - V{0.0555555555555556}*cell[4] + V{0.0277777777777778}*cell[5];
auto x228 = x220 + x221 + x222 + x224 + x227;
auto x229 = x223*x71;
auto x230 = -V{0.0555555555555556}*cell[19] + V{0.0277777777777778}*cell[20] - V{0.0555555555555556}*cell[6] + V{0.0277777777777778}*cell[7];
auto x231 = x229 + x230;
auto x232 = V{0.0416666666666667}*x34*x61*x71;
auto x233 = V{0.0138888888888889}*cell[11];
auto x234 = V{0.0138888888888889}*cell[12];
auto x235 = V{0.0138888888888889}*cell[24];
auto x236 = V{0.0138888888888889}*cell[25];
auto x237 = V{0.0138888888888889}*cell[0];
auto x238 = -V{1.15648231731787e-18}*cell[1];
auto x239 = -V{1.15648231731787e-18}*cell[2];
auto x240 = -V{1.15648231731787e-18}*cell[3];
auto x241 = -V{1.15648231731787e-18}*cell[14];
auto x242 = -V{1.15648231731787e-18}*cell[15];
auto x243 = -V{1.15648231731787e-18}*cell[16];
auto x244 = x233 + x234 + x235 + x236 + x237 + x238 + x239 + x240 + x241 + x242 + x243 - V{0.0555555555555556}*cell[21] + V{0.0277777777777778}*cell[22] - V{0.0555555555555556}*cell[8] + V{0.0277777777777778}*cell[9];
auto x245 = x232 + x244;
auto x246 = -V{0.152777777777778}*cell[10] - V{0.152777777777778}*cell[23];
auto x247 = V{0.00462962962962963}*cell[0] + V{0.00462962962962963}*cell[10] + V{0.00462962962962963}*cell[11] + V{0.00462962962962963}*cell[12] + V{0.00462962962962963}*cell[13] + V{0.00462962962962963}*cell[14] + V{0.00462962962962963}*cell[15] + V{0.00462962962962963}*cell[16] + V{0.00462962962962963}*cell[17] + V{0.00462962962962963}*cell[18] + V{0.00462962962962963}*cell[19] + V{0.00462962962962963}*cell[1] + V{0.00462962962962963}*cell[20] + V{0.00462962962962963}*cell[21] + V{0.00462962962962963}*cell[22] + V{0.00462962962962963}*cell[23] + V{0.00462962962962963}*cell[24] + V{0.00462962962962963}*cell[25] + V{0.00462962962962963}*cell[26] + V{0.00462962962962963}*cell[2] + V{0.00462962962962963}*cell[3] + V{0.00462962962962963}*cell[4] + V{0.00462962962962963}*cell[5] + V{0.00462962962962963}*cell[6] + V{0.00462962962962963}*cell[7] + V{0.00462962962962963}*cell[8] + V{0.00462962962962963}*cell[9] + V{0.00462962962962963};
auto x248 = x132 + x184;
auto x249 = x187 + x204 + x248 + x31 + x39 + x51 + x64 + V{3}*cell[10] - V{3}*cell[23];
auto x250 = -x249;
auto x251 = V{0.0138888888888889}*cell[10];
auto x252 = V{0.0138888888888889}*cell[23];
auto x253 = x251 + x252 + V{0.0277777777777778}*cell[19] - V{0.0555555555555556}*cell[20] + V{0.0277777777777778}*cell[6] - V{0.0555555555555556}*cell[7];
auto x254 = -x229 + x253;
auto x255 = x237 + x238 + x239 + x240 + x241 + x242 + x243 + V{0.0277777777777778}*cell[21] - V{0.0555555555555556}*cell[22] + V{0.0277777777777778}*cell[8] - V{0.0555555555555556}*cell[9];
auto x256 = -x232 + x255;
auto x257 = x234 + x236 - V{0.152777777777778}*cell[11] - V{0.152777777777778}*cell[24];
auto x258 = x197 + x201 + x216 + x248 + x40 + x47 + x59 + V{3}*cell[11] + cell[16] - V{3}*cell[24];
auto x259 = V{0.0277777777777778}*cell[17] - V{0.0555555555555556}*cell[18] + V{0.0277777777777778}*cell[4] - V{0.0555555555555556}*cell[5];
auto x260 = x220 + x221 + x222 - x224 + x259;
auto x261 = x225 + x226 + x233 + x235 + x251 + x252 - V{0.152777777777778}*cell[12] - V{0.152777777777778}*cell[25];
auto x262 = x171 + x184 + x188 + x214 - x215 + x47 + x69 + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x263 = -V{0.152777777777778}*cell[13] - V{0.152777777777778}*cell[26];
auto x264 = x112*x219;
auto x265 = x110*x219;
auto x266 = x219*x99;
auto x267 = V{0.0416666666666667}*x210;
auto x268 = x244 + x264 + x265 + x266 + x267;
auto x269 = V{0.0416666666666667}*x48;
auto x270 = x191*x269;
auto x271 = x253 - x270;
auto x272 = x137*x269;
auto x273 = x259 - x272;
auto x274 = x34*x95;
auto x275 = x131 + x169 - x170 + x199 - x200 + x205 + x59 + x69 - V{3}*cell[13] + cell[14] - cell[1] + V{3}*cell[26];
auto x276 = -x275;
auto x277 = x123*x34;
auto x278 = x112*x74;
auto x279 = x110*x74 + V{-1};
auto x280 = x278 + x279;
auto x281 = x118*x34;
auto x282 = x74*x99;
auto x283 = x281 + x282;
auto x284 = x277 + x280 + x283;
auto x285 = x32 + V{1};
auto x286 = x274 + x280;
auto x287 = x277 + x282;
auto x288 = x283 + x286;
auto x289 = -x96;
auto x290 = -x172;
auto x291 = x286 + x287;
auto x292 = -x202;
auto x293 = x124 + x79;
auto x294 = -x217;
auto x295 = x227 + x272;
auto x296 = x230 + x270;
auto x297 = x255 + x264 + x265 + x266 - x267;
auto x298 = -x258;
auto x299 = -x262;
auto x0 = x27*(-x35*x50 - x35*x62 - x35*x72 - V{0.444444444444444}*cell[0] + V{0.888888888888889}*cell[10] + V{0.888888888888889}*cell[11] + V{0.888888888888889}*cell[12] + V{0.888888888888889}*cell[13] + V{3.70074341541719e-17}*cell[14] + V{3.70074341541719e-17}*cell[15] + V{3.70074341541719e-17}*cell[16] + V{0.444444444444444}*cell[17] + V{0.444444444444444}*cell[18] + V{0.444444444444444}*cell[19] + V{3.70074341541719e-17}*cell[1] + V{0.444444444444444}*cell[20] + V{0.444444444444444}*cell[21] + V{0.444444444444444}*cell[22] + V{0.888888888888889}*cell[23] + V{0.888888888888889}*cell[24] + V{0.888888888888889}*cell[25] + V{0.888888888888889}*cell[26] + V{3.70074341541719e-17}*cell[2] + V{3.70074341541719e-17}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444}*cell[9]) - x79*(V{0.296296296296296}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9] + V{0.296296296296296}) + V{-0.296296296296296};
auto x1 = -x114 - x80*(-x50*x97 + x78 + x96);
auto x2 = -x122 - x80*(x119 + x120 - x62*x97 + x77);
auto x3 = -x125 - x80*(x120 + x124 - x72*x97 + x76);
auto x4 = -x126*(-x127*x134*x134 + x136) - x162;
auto x5 = -x126*(-x127*x172*x172 + x174) - x183;
auto x6 = -x126*(x124 - x127*x190*x190 + x135) - x195;
auto x7 = -x126*(-x127*x202*x202 + x135 + x196) - x203;
auto x8 = -x126*(-x127*x207*x207 + x209) - x213;
auto x9 = -x126*(-x127*x217*x217 + x196 + x208) - x218;
auto x10 = -x247*(x124 - x127*x250*x250 + x136) + x27*(x228 + x231 + x245 + x246) + V{-0.00462962962962963};
auto x11 = -x247*(-x127*x258*x258 + x136 + x196) + x27*(x228 + x254 + x256 + x257) + V{-0.00462962962962963};
auto x12 = -x247*(x124 - x127*x262*x262 + x174) + x27*(x231 + x256 + x260 + x261) + V{-0.00462962962962963};
auto x13 = -x247*(-x127*x276*x276 - x274 + x284) + x27*(x263 + x268 + x271 + x273) + V{-0.00462962962962963};
auto x14 = -x114 + V{0.0740740740740741}*x285*(-x286 + V{3}*x73*x99);
auto x15 = -x122 + V{0.0740740740740741}*x285*(V{3}*x112*x73 - x279 - x283);
auto x16 = -x125 + V{0.0740740740740741}*x285*(V{3}*x110*x73 - x278 - x287 + V{1});
auto x17 = -x162 - V{0.0185185185185185}*x285*(x288 - V{4.5}*x73*x133*x133);
auto x18 = -x126*(-x127*x290*x290 + x208 + x289) - x183;
auto x19 = -x195 - V{0.0185185185185185}*x285*(x291 - V{4.5}*x73*x189*x189);
auto x20 = -x126*(-x127*x292*x292 + x289 + x293) - x203;
auto x21 = -x213 - V{0.0185185185185185}*x285*(x284 - V{4.5}*x73*x206*x206);
auto x22 = -x126*(-x127*x294*x294 + x173 + x293) - x218;
auto x23 = -x247*(-x127*x249*x249 + x277 + x288) + x27*(x246 + x268 + x295 + x296) + V{-0.00462962962962963};
auto x24 = -x247*(-x127*x298*x298 - x277 + x288) + x27*(x257 + x271 + x295 + x297) + V{-0.00462962962962963};
auto x25 = -x247*(-x127*x299*x299 - x281 + x291) + x27*(x261 + x273 + x296 + x297) + V{-0.00462962962962963};
auto x26 = -x247*(-x127*x275*x275 + x209 + x289) + x27*(x245 + x254 + x260 + x263) + V{-0.00462962962962963};
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
cell[19] = x19;
cell[20] = x20;
cell[21] = x21;
cell[22] = x22;
cell[23] = x23;
cell[24] = x24;
cell[25] = x25;
cell[26] = x26;
return { x33, V{1}*x73*(x110 + x112 + x99) };
}
 
};
 
 
template <typename... FIELDS>
struct PerPopulationBGK::type<descriptors::D2Q5<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[4];
auto x10 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[3];
auto x8 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[1];
auto x9 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[2];
auto x7 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[0];
auto x5 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4];
auto x6 = x5 + V{1};
auto x12 = x5 + V{1};
auto x13 = V{1} / ((x12)*(x12));
auto x14 = V{1.5}*x13;
auto x15 = cell[2] - cell[4];
auto x16 = -x15;
auto x17 = x16*x16;
auto x18 = cell[1] - cell[3];
auto x19 = -x18;
auto x20 = x14*(x19*x19) + V{-1};
auto x21 = V{1} / (x12);
auto x22 = x21*(V{3}*cell[1] - V{3}*cell[3]);
auto x23 = V{3}*x13;
auto x24 = x18*x18;
auto x25 = x15*x15;
auto x26 = x14*x25;
auto x27 = V{3}*cell[2] - V{3}*cell[4];
cell[0] = -V{0.333333333333333}*x7*(x6*(x14*x17 + x20) + V{1}) - (x7 + V{-1})*cell[0];
cell[1] = V{0.166666666666667}*x8*(x6*(x22 + x23*x24 - x26 + V{1}) + V{-1}) - (x8 + V{-1})*cell[1];
cell[2] = -V{0.166666666666667}*x9*(x6*(-x17*x23 + x20 - x21*x27) + V{1}) - (x9 + V{-1})*cell[2];
cell[3] = V{0.166666666666667}*x10*(x6*(V{3}*x13*x24 - x22 - x26 + V{1}) + V{-1}) - (x10 + V{-1})*cell[3];
cell[4] = -V{0.166666666666667}*x11*(x6*(x14*x24 + x21*x27 - x23*x25 + V{-1}) + V{1}) - (x11 + V{-1})*cell[4];
return { x12, V{1}*x13*(x24 + x25) };
}
 
};
 
template <typename... FIELDS>
struct PerPopulationBGK::type<descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x15 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[4];
auto x11 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[0];
auto x17 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[6];
auto x14 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[3];
auto x18 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[7];
auto x13 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[2];
auto x12 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[1];
auto x19 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[8];
auto x16 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[5];
auto x9 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8];
auto x10 = x9 + V{1};
auto x20 = x9 + V{1};
auto x21 = V{1} / ((x20)*(x20));
auto x22 = V{1.5}*x21;
auto x23 = cell[1] - cell[5];
auto x24 = -cell[4] + cell[8];
auto x25 = x23 + x24 - cell[3] + cell[7];
auto x26 = x25*x25;
auto x27 = x22*x26;
auto x28 = cell[2] - cell[6];
auto x29 = x23 + x28 + cell[3] - cell[7];
auto x30 = -x29;
auto x31 = x22*(x30*x30) + V{-1};
auto x32 = x27 + x31;
auto x33 = V{4.5}*x21;
auto x34 = x24 + x28 + V{2}*cell[1] - V{2}*cell[5];
auto x35 = x33*(x34*x34);
auto x36 = V{1} / (x20);
auto x37 = V{3}*cell[3];
auto x38 = V{3}*cell[7];
auto x39 = V{3}*cell[1] - V{3}*cell[5];
auto x40 = x37 - x38 + x39 + V{3}*cell[2] - V{3}*cell[6];
auto x41 = x36*x40;
auto x42 = -x27 + x41 + V{1};
auto x43 = -x37 + x38 + x39 - V{3}*cell[4] + V{3}*cell[8];
auto x44 = x36*x43;
auto x45 = x29*x29;
auto x46 = x22*x45;
auto x47 = x44 - x46;
auto x48 = V{3}*x21;
auto x49 = x28 + V{2}*cell[3] + cell[4] - V{2}*cell[7] - cell[8];
auto x50 = -x49;
auto x51 = x26*x48;
auto x52 = x27 + x41 + V{-1};
auto x53 = x46 + x52;
cell[0] = -V{0.444444444444444}*x11*(x10*x32 + V{1}) - (x11 + V{-1})*cell[0];
cell[1] = V{0.0277777777777778}*x12*(x10*(x35 + x42 + x47) + V{-1}) - (x12 + V{-1})*cell[1];
cell[2] = V{0.111111111111111}*x13*(x10*(x42 + x45*x48) + V{-1}) - (x13 + V{-1})*cell[2];
cell[3] = -V{0.0277777777777778}*x14*(x10*(x32 - x33*x50*x50 - x36*x40 + x44) + V{1}) - (x14 + V{-1})*cell[3];
cell[4] = -V{0.111111111111111}*x15*(x10*(x31 + x44 - x51) + V{1}) - (x15 + V{-1})*cell[4];
cell[5] = -V{0.0277777777777778}*x16*(x10*(-x35 + x44 + x53) + V{1}) - (x16 + V{-1})*cell[5];
cell[6] = V{0.111111111111111}*x17*(x10*(V{3}*x21*x45 - x52) + V{-1}) - (x17 + V{-1})*cell[6];
cell[7] = V{0.0277777777777778}*x18*(-x10*(-V{4.5}*x21*x49*x49 - x36*x43 + x53) + V{-1}) - (x18 + V{-1})*cell[7];
cell[8] = V{0.111111111111111}*x19*(x10*(x47 + x51 + V{1}) + V{-1}) - (x19 + V{-1})*cell[8];
return { x20, V{1}*x21*(x26 + x45) };
}
 
};
 
template <typename... FIELDS>
struct PerPopulationBGK::type<descriptors::D3Q7<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x15 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[5];
auto x11 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[1];
auto x10 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[0];
auto x14 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[4];
auto x13 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[3];
auto x12 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[2];
auto x16 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[6];
auto x7 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6];
auto x8 = x7 + V{1};
auto x9 = x7 + V{1};
auto x17 = V{1} / ((x9)*(x9));
auto x18 = V{2}*x17;
auto x19 = cell[1] - cell[4];
auto x20 = -x19;
auto x21 = x20*x20;
auto x22 = x18*x21;
auto x23 = cell[2] - cell[5];
auto x24 = -x23;
auto x25 = x24*x24;
auto x26 = x18*x25;
auto x27 = cell[3] - cell[6];
auto x28 = -x27;
auto x29 = x28*x28;
auto x30 = x18*x29;
auto x31 = x26 + x30 + V{-1};
auto x32 = V{1} / (x9);
auto x33 = V{4}*cell[1] - V{4}*cell[4];
auto x34 = V{6}*x17;
auto x35 = V{4}*cell[2] - V{4}*cell[5];
auto x36 = x22 + V{-1};
auto x37 = V{4}*cell[3] - V{4}*cell[6];
auto x38 = x23*x23;
auto x39 = x18*x38;
auto x40 = x19*x19;
auto x41 = x27*x27;
auto x42 = x18*x41 + V{-1};
auto x43 = x18*x40;
cell[0] = -V{0.25}*x10*(x8*(x22 + x31) + V{1}) - (x10 + V{-1})*cell[0];
cell[1] = -V{0.125}*x11*(x8*(-x21*x34 + x31 - x32*x33) + V{1}) - (x11 + V{-1})*cell[1];
cell[2] = -V{0.125}*x12*(x8*(-x25*x34 + x30 - x32*x35 + x36) + V{1}) - (x12 + V{-1})*cell[2];
cell[3] = -V{0.125}*x13*(x8*(x26 - x29*x34 - x32*x37 + x36) + V{1}) - (x13 + V{-1})*cell[3];
cell[4] = -V{0.125}*x14*(x8*(x32*x33 - x34*x40 + x39 + x42) + V{1}) - (x14 + V{-1})*cell[4];
cell[5] = -V{0.125}*x15*(x8*(x32*x35 - x34*x38 + x42 + x43) + V{1}) - (x15 + V{-1})*cell[5];
cell[6] = -V{0.125}*x16*(x8*(x32*x37 - x34*x41 + x39 + x43 + V{-1}) + V{1}) - (x16 + V{-1})*cell[6];
return { x9, V{1}*x17*(x38 + x40 + x41) };
}
 
};
 
template <typename... FIELDS>
struct PerPopulationBGK::type<descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x27 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[5];
auto x33 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[11];
auto x32 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[10];
auto x40 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[18];
auto x35 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[13];
auto x31 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[9];
auto x37 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[15];
auto x30 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[8];
auto x29 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[7];
auto x34 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[12];
auto x25 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[3];
auto x38 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[16];
auto x24 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[2];
auto x36 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[14];
auto x28 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[6];
auto x22 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[0];
auto x26 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[4];
auto x23 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[1];
auto x39 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[17];
auto x19 = cell[10] + cell[14];
auto x20 = cell[12] + cell[7];
auto x21 = x19 + x20 + cell[0] + cell[11] + cell[13] + cell[15] + cell[16] + cell[17] + cell[18] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + cell[9];
auto x41 = x21 + V{1};
auto x42 = x21 + V{1};
auto x43 = V{1} / ((x42)*(x42));
auto x44 = V{1.5}*x43;
auto x45 = cell[13] - cell[4];
auto x46 = cell[15] - cell[6];
auto x47 = x45 + x46;
auto x48 = -cell[1];
auto x49 = cell[16] - cell[7];
auto x50 = x48 + x49;
auto x51 = x19 - cell[5];
auto x52 = x47 + x50 + x51;
auto x53 = x52*x52;
auto x54 = x44*x53;
auto x55 = cell[17] - cell[8];
auto x56 = x45 + x55;
auto x57 = cell[18] - cell[9];
auto x58 = -cell[2];
auto x59 = x58 + cell[11] - cell[14] + cell[5];
auto x60 = x56 + x57 + x59;
auto x61 = x60*x60;
auto x62 = x44*x61;
auto x63 = x46 + x55;
auto x64 = -cell[3];
auto x65 = -cell[18] + cell[9];
auto x66 = x64 + x65;
auto x67 = x20 - cell[16];
auto x68 = x63 + x66 + x67;
auto x69 = x68*x68;
auto x70 = x44*x69;
auto x71 = x62 + x70 + V{-1};
auto x72 = x54 + x71;
auto x73 = V{1} / (x42);
auto x74 = V{3}*cell[14];
auto x75 = V{3}*cell[16];
auto x76 = V{3}*cell[5];
auto x77 = V{3}*cell[7];
auto x78 = V{3}*cell[13] - V{3}*cell[4];
auto x79 = V{3}*cell[15] - V{3}*cell[6];
auto x80 = x73*(x74 + x75 - x76 - x77 + x78 + x79 + V{3}*cell[10] - V{3}*cell[1]);
auto x81 = V{3}*x43;
auto x82 = x53*x81;
auto x83 = V{3}*cell[18];
auto x84 = V{3}*cell[9];
auto x85 = V{3}*cell[17] - V{3}*cell[8];
auto x86 = x73*(-x74 + x76 + x78 + x83 - x84 + x85 + V{3}*cell[11] - V{3}*cell[2]);
auto x87 = x61*x81;
auto x88 = x54 + V{-1};
auto x89 = x73*(-x75 + x77 + x79 - x83 + x84 + x85 + V{3}*cell[12] - V{3}*cell[3]);
auto x90 = x69*x81;
auto x91 = V{4.5}*x43;
auto x92 = x50 + cell[10];
auto x93 = x57 + x58 + x63 + x92 + cell[11] + V{2}*cell[13] - V{2}*cell[4];
auto x94 = x91*(x93*x93);
auto x95 = x72 + x80;
auto x96 = -x86;
auto x97 = -cell[17] + cell[8];
auto x98 = x46 + x65 + x92 + x97 - cell[11] + V{2}*cell[14] + cell[2] - V{2}*cell[5];
auto x99 = -x98;
auto x100 = x48 + x51;
auto x101 = x100 + x56 + x66 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x102 = x91*(x101*x101);
auto x103 = -x89;
auto x104 = x45 - cell[12] + cell[3];
auto x105 = x100 + x104 + x57 + x97 + V{2}*cell[16] - V{2}*cell[7];
auto x106 = -x105;
auto x107 = x47 + x59 + x64 + x67 + V{2}*cell[17] - V{2}*cell[8];
auto x108 = x91*(x107*x107);
auto x109 = x72 + x86;
auto x110 = x104 + x49 + x59 - cell[15] + V{2}*cell[18] + cell[6] - V{2}*cell[9];
auto x111 = -x110;
auto x112 = -x62;
auto x113 = V{1} - x70;
auto x114 = x112 + x113;
auto x115 = x114 + x80;
auto x116 = -x54;
auto x117 = x116 + x86;
auto x118 = x116 + x89;
auto x119 = -x80;
auto x120 = x72 + x89;
cell[0] = -V{0.333333333333333}*x22*(x41*x72 + V{1}) - (x22 + V{-1})*cell[0];
cell[1] = -V{0.0555555555555556}*x23*(x41*(x71 + x80 - x82) + V{1}) - (x23 + V{-1})*cell[1];
cell[2] = -V{0.0555555555555556}*x24*(x41*(x70 + x86 - x87 + x88) + V{1}) - (x24 + V{-1})*cell[2];
cell[3] = -V{0.0555555555555556}*x25*(x41*(x62 + x88 + x89 - x90) + V{1}) - (x25 + V{-1})*cell[3];
cell[4] = -V{0.0277777777777778}*x26*(x41*(x86 - x94 + x95) + V{1}) - (x26 + V{-1})*cell[4];
cell[5] = -V{0.0277777777777778}*x27*(x41*(-x91*x99*x99 + x95 + x96) + V{1}) - (x27 + V{-1})*cell[5];
cell[6] = -V{0.0277777777777778}*x28*(x41*(-x102 + x89 + x95) + V{1}) - (x28 + V{-1})*cell[6];
cell[7] = -V{0.0277777777777778}*x29*(x41*(x103 - x91*x106*x106 + x95) + V{1}) - (x29 + V{-1})*cell[7];
cell[8] = -V{0.0277777777777778}*x30*(x41*(-x108 + x109 + x89) + V{1}) - (x30 + V{-1})*cell[8];
cell[9] = -V{0.0277777777777778}*x31*(x41*(x103 + x109 - x91*x111*x111) + V{1}) - (x31 + V{-1})*cell[9];
cell[10] = V{0.0555555555555556}*x32*(x41*(x115 + x82) + V{-1}) - (x32 + V{-1})*cell[10];
cell[11] = V{0.0555555555555556}*x33*(x41*(x113 + x117 + x87) + V{-1}) - (x33 + V{-1})*cell[11];
cell[12] = V{0.0555555555555556}*x34*(x41*(x112 + x118 + x90 + V{1}) + V{-1}) - (x34 + V{-1})*cell[12];
cell[13] = V{0.0277777777777778}*x35*(x41*(x115 + x117 + x94) + V{-1}) - (x35 + V{-1})*cell[13];
cell[14] = -V{0.0277777777777778}*x36*(x41*(x109 + x119 - x91*x98*x98) + V{1}) - (x36 + V{-1})*cell[14];
cell[15] = V{0.0277777777777778}*x37*(x41*(x102 + x115 + x118) + V{-1}) - (x37 + V{-1})*cell[15];
cell[16] = -V{0.0277777777777778}*x38*(x41*(x119 + x120 - x91*x105*x105) + V{1}) - (x38 + V{-1})*cell[16];
cell[17] = V{0.0277777777777778}*x39*(x41*(x108 + x114 + x117 + x89) + V{-1}) - (x39 + V{-1})*cell[17];
cell[18] = -V{0.0277777777777778}*x40*(x41*(x120 - x91*x110*x110 + x96) + V{1}) - (x40 + V{-1})*cell[18];
return { x42, V{1}*x43*(x53 + x61 + x69) };
}
 
};
 
template <typename... FIELDS>
struct PerPopulationBGK::type<descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x56 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[26];
auto x49 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[19];
auto x48 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[18];
auto x54 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[24];
auto x33 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[3];
auto x32 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[2];
auto x45 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[15];
auto x40 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[10];
auto x35 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[5];
auto x31 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[1];
auto x37 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[7];
auto x50 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[20];
auto x30 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[0];
auto x53 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[23];
auto x55 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[25];
auto x51 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[21];
auto x43 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[13];
auto x46 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[16];
auto x34 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[4];
auto x38 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[8];
auto x44 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[14];
auto x36 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[6];
auto x52 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[22];
auto x42 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[12];
auto x41 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[11];
auto x39 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[9];
auto x47 = parameters.template get<olb::collision::PerPopulationBGK::OMEGA>()[17];
auto x27 = cell[8] + cell[9];
auto x28 = cell[15] + cell[21];
auto x29 = cell[11] + cell[26];
auto x57 = x27 + x28 + x29 + cell[0] + cell[10] + cell[12] + cell[13] + cell[14] + cell[16] + cell[17] + cell[18] + cell[19] + cell[1] + cell[20] + cell[22] + cell[23] + cell[24] + cell[25] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7];
auto x58 = x57 + V{1};
auto x59 = x57 + V{1};
auto x60 = V{1} / ((x59)*(x59));
auto x61 = V{1.5}*x60;
auto x62 = -cell[17];
auto x63 = -cell[19];
auto x64 = x62 + x63 + cell[4] + cell[6];
auto x65 = -cell[24];
auto x66 = cell[10] - cell[23];
auto x67 = x65 + x66 + cell[11];
auto x68 = cell[12] - cell[25];
auto x69 = -cell[14];
auto x70 = -cell[20] + cell[7];
auto x71 = x69 + x70 + cell[1];
auto x72 = -cell[18] + cell[5];
auto x73 = cell[13] - cell[26];
auto x74 = x64 + x67 + x68 + x71 + x72 + x73;
auto x75 = -x74;
auto x76 = x75*x75;
auto x77 = x61*x76;
auto x78 = -cell[13];
auto x79 = -cell[21];
auto x80 = x78 + x79 + cell[26] + cell[8];
auto x81 = -cell[22];
auto x82 = x62 + cell[4];
auto x83 = x81 + x82 + cell[9];
auto x84 = -cell[15];
auto x85 = x84 + cell[18] + cell[2] - cell[5];
auto x86 = -cell[12] + cell[25];
auto x87 = x67 + x80 + x83 + x85 + x86;
auto x88 = -x87;
auto x89 = x88*x88;
auto x90 = x61*x89;
auto x91 = -cell[16];
auto x92 = x68 + x91 + cell[3];
auto x93 = -cell[9];
auto x94 = x63 + cell[6];
auto x95 = x93 + x94 + cell[22];
auto x96 = cell[20] - cell[7];
auto x97 = x66 - cell[11] + cell[24];
auto x98 = x80 + x92 + x95 + x96 + x97;
auto x99 = -x98;
auto x100 = x99*x99;
auto x101 = x100*x61;
auto x102 = x101 + x90 + V{-1};
auto x103 = x102 + x77;
auto x104 = V{1} / (x59);
auto x105 = V{3}*cell[5];
auto x106 = V{3}*cell[7];
auto x107 = V{3}*cell[13];
auto x108 = V{3}*cell[18];
auto x109 = V{3}*cell[20];
auto x110 = V{3}*cell[26];
auto x111 = V{3}*cell[10];
auto x112 = V{3}*cell[11];
auto x113 = -V{3}*cell[23];
auto x114 = V{3}*cell[24];
auto x115 = x111 + x112 + x113 - x114 - V{3}*cell[17] + V{3}*cell[4];
auto x116 = V{3}*cell[12];
auto x117 = V{3}*cell[25];
auto x118 = x116 - x117 - V{3}*cell[19] + V{3}*cell[6];
auto x119 = x105 + x106 + x107 - x108 - x109 - x110 + x115 + x118 - V{3}*cell[14] + V{3}*cell[1];
auto x120 = -x104*x119;
auto x121 = V{3}*x60;
auto x122 = V{3}*cell[9];
auto x123 = V{3}*cell[22];
auto x124 = -x107 + x110 - V{3}*cell[21] + V{3}*cell[8];
auto x125 = -x105 + x108 + x115 - x116 + x117 + x122 - x123 + x124 - V{3}*cell[15] + V{3}*cell[2];
auto x126 = -x104*x125;
auto x127 = x77 + V{-1};
auto x128 = -x106 + x109 + x111 - x112 + x113 + x114 + x118 - x122 + x123 + x124 - V{3}*cell[16] + V{3}*cell[3];
auto x129 = -x104*x128;
auto x130 = V{4.5}*x60;
auto x131 = V{2}*cell[11] - V{2}*cell[24];
auto x132 = V{2}*cell[10] - V{2}*cell[23];
auto x133 = x132 + x79;
auto x134 = x84 + cell[2];
auto x135 = x134 - V{2}*cell[17] + V{2}*cell[4];
auto x136 = x131 + x133 + x135 + x27 + x71 + x81 + x94;
auto x137 = -x136;
auto x138 = x103 + x120;
auto x139 = x126 + x138;
auto x140 = V{2}*cell[25];
auto x141 = V{2}*cell[12];
auto x142 = -x140 + x141;
auto x143 = V{2}*cell[26];
auto x144 = V{2}*cell[13];
auto x145 = -x143 + x144 - cell[8];
auto x146 = V{2}*cell[18];
auto x147 = V{2}*cell[5];
auto x148 = -x146 + x147 - cell[2];
auto x149 = x142 + x145 + x148 + x28 + x71 + x95;
auto x150 = -x126;
auto x151 = x138 + x150;
auto x152 = x69 + cell[1];
auto x153 = x152 + x72;
auto x154 = x91 + cell[3];
auto x155 = -V{2}*cell[19] + V{2}*cell[6];
auto x156 = x154 + x155;
auto x157 = x133 + x142 + x153 + x156 + x82 + x93 + cell[22] + cell[8];
auto x158 = -x157;
auto x159 = -x129;
auto x160 = -cell[3];
auto x161 = x131 + x160 + cell[16];
auto x162 = V{2}*cell[20];
auto x163 = V{2}*cell[7];
auto x164 = -x162 + x163;
auto x165 = x145 + x153 + x161 + x164 + x83 + cell[21];
auto x166 = -V{2}*cell[21] + V{2}*cell[8];
auto x167 = x154 + x166;
auto x168 = x132 + x143 - x144 + x167 + x64 + x85 + x96;
auto x169 = -x168;
auto x170 = x103 + x126;
auto x171 = x129 + x170;
auto x172 = V{2}*cell[22];
auto x173 = V{2}*cell[9];
auto x174 = -x172 + x173;
auto x175 = x140 - x141 + x161 + x174 + x70 + x82 + x85 + cell[19] - cell[6];
auto x176 = x135 + x152;
auto x177 = x155 + x166 + x176 + x29 + x65 + x78 + x92 + V{3}*cell[10] - V{3}*cell[23];
auto x178 = -x177;
auto x179 = x160 + x164 + x174 + x176 + x66 + x73 + x86 + V{3}*cell[11] + cell[16] - V{3}*cell[24];
auto x180 = x148 + x152 + x156 + x172 - x173 + x73 + x97 + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x181 = x104*x119;
auto x182 = x134 + x146 - x147 + x162 - x163 + x167 + x86 + x97 - V{3}*cell[13] + cell[14] - cell[1] + V{3}*cell[26];
auto x183 = -x182;
auto x184 = x104*x128;
auto x185 = x87*x87;
auto x186 = x185*x61;
auto x187 = x98*x98;
auto x188 = x187*x61 + V{-1};
auto x189 = x186 + x188;
auto x190 = x104*x125;
auto x191 = x74*x74;
auto x192 = x191*x61;
auto x193 = x190 + x192;
auto x194 = x184 + x189 + x193;
auto x195 = x181 + x189;
auto x196 = x184 + x192;
auto x197 = x193 + x195;
auto x198 = -x120;
auto x199 = -x149;
auto x200 = x195 + x196;
auto x201 = -x165;
auto x202 = x103 + x129;
auto x203 = -x175;
auto x204 = -x179;
auto x205 = -x180;
cell[0] = -V{0.296296296296296}*x30*(x103*x58 + V{1}) - (x30 + V{-1})*cell[0];
cell[1] = -V{0.0740740740740741}*x31*(x58*(x102 + x120 - x121*x76) + V{1}) - (x31 + V{-1})*cell[1];
cell[2] = -V{0.0740740740740741}*x32*(x58*(x101 - x121*x89 + x126 + x127) + V{1}) - (x32 + V{-1})*cell[2];
cell[3] = -V{0.0740740740740741}*x33*(x58*(-x100*x121 + x127 + x129 + x90) + V{1}) - (x33 + V{-1})*cell[3];
cell[4] = -V{0.0185185185185185}*x34*(x58*(-x130*x137*x137 + x139) + V{1}) - (x34 + V{-1})*cell[4];
cell[5] = -V{0.0185185185185185}*x35*(x58*(-x130*x149*x149 + x151) + V{1}) - (x35 + V{-1})*cell[5];
cell[6] = -V{0.0185185185185185}*x36*(x58*(x129 - x130*x158*x158 + x138) + V{1}) - (x36 + V{-1})*cell[6];
cell[7] = -V{0.0185185185185185}*x37*(x58*(-x130*x165*x165 + x138 + x159) + V{1}) - (x37 + V{-1})*cell[7];
cell[8] = -V{0.0185185185185185}*x38*(x58*(-x130*x169*x169 + x171) + V{1}) - (x38 + V{-1})*cell[8];
cell[9] = -V{0.0185185185185185}*x39*(x58*(-x130*x175*x175 + x159 + x170) + V{1}) - (x39 + V{-1})*cell[9];
cell[10] = -V{0.00462962962962963}*x40*(x58*(x129 - x130*x178*x178 + x139) + V{1}) - (x40 + V{-1})*cell[10];
cell[11] = -V{0.00462962962962963}*x41*(x58*(-x130*x179*x179 + x139 + x159) + V{1}) - (x41 + V{-1})*cell[11];
cell[12] = -V{0.00462962962962963}*x42*(x58*(x129 - x130*x180*x180 + x151) + V{1}) - (x42 + V{-1})*cell[12];
cell[13] = -V{0.00462962962962963}*x43*(x58*(-x130*x183*x183 - x181 + x194) + V{1}) - (x43 + V{-1})*cell[13];
cell[14] = -V{0.0740740740740741}*x44*(x58*(-x121*x191 + x195) + V{1}) - (x44 + V{-1})*cell[14];
cell[15] = -V{0.0740740740740741}*x45*(x58*(-x121*x185 + x188 + x193) + V{1}) - (x45 + V{-1})*cell[15];
cell[16] = -V{0.0740740740740741}*x46*(x58*(-x121*x187 + x186 + x196 + V{-1}) + V{1}) - (x46 + V{-1})*cell[16];
cell[17] = -V{0.0185185185185185}*x47*(x58*(-x130*x136*x136 + x197) + V{1}) - (x47 + V{-1})*cell[17];
cell[18] = -V{0.0185185185185185}*x48*(x58*(-x130*x199*x199 + x170 + x198) + V{1}) - (x48 + V{-1})*cell[18];
cell[19] = -V{0.0185185185185185}*x49*(x58*(-x130*x157*x157 + x200) + V{1}) - (x49 + V{-1})*cell[19];
cell[20] = -V{0.0185185185185185}*x50*(x58*(-x130*x201*x201 + x198 + x202) + V{1}) - (x50 + V{-1})*cell[20];
cell[21] = -V{0.0185185185185185}*x51*(x58*(-x130*x168*x168 + x194) + V{1}) - (x51 + V{-1})*cell[21];
cell[22] = -V{0.0185185185185185}*x52*(x58*(-x130*x203*x203 + x150 + x202) + V{1}) - (x52 + V{-1})*cell[22];
cell[23] = -V{0.00462962962962963}*x53*(x58*(-x130*x177*x177 + x184 + x197) + V{1}) - (x53 + V{-1})*cell[23];
cell[24] = -V{0.00462962962962963}*x54*(x58*(-x130*x204*x204 - x184 + x197) + V{1}) - (x54 + V{-1})*cell[24];
cell[25] = -V{0.00462962962962963}*x55*(x58*(-x130*x205*x205 - x190 + x200) + V{1}) - (x55 + V{-1})*cell[25];
cell[26] = -V{0.00462962962962963}*x56*(x58*(-x130*x182*x182 + x171 + x198) + V{1}) - (x56 + V{-1})*cell[26];
return { x59, V{1}*x60*(x185 + x187 + x191) };
}
 
};
 
 
template <typename... FIELDS>
struct TRT::type<descriptors::D2Q5<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x8 = parameters.template get<olb::collision::TRT::MAGIC>();
auto x7 = parameters.template get<olb::descriptors::OMEGA>();
auto x5 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + V{1};
auto x6 = V{1} / ((x5)*(x5));
auto x9 = V{1.5}*x6;
auto x10 = -cell[3];
auto x11 = x10 + cell[1];
auto x12 = -x11;
auto x13 = x12*x12;
auto x14 = x13*x9;
auto x15 = -cell[4];
auto x16 = x15 + cell[2];
auto x17 = -x16;
auto x18 = x17*x17;
auto x19 = x18*x9;
auto x20 = x19 + V{-1};
auto x21 = V{1} / (-x8/(V{0.5} - V{1}/x7) + V{0.5});
auto x22 = V{0.5}*cell[3];
auto x23 = V{0.5}*cell[1];
auto x24 = V{0.0833333333333333}*cell[0] + V{0.0833333333333333}*cell[1] + V{0.0833333333333333}*cell[2] + V{0.0833333333333333}*cell[3] + V{0.0833333333333333}*cell[4] + V{0.0833333333333333};
auto x25 = V{1} / (x5);
auto x26 = V{3}*cell[1] - V{3}*cell[3];
auto x27 = -x25*x26;
auto x28 = V{3}*x6;
auto x29 = x25*x26;
auto x30 = x16*x16;
auto x31 = x30*x9;
auto x32 = x11*x11;
auto x33 = x24*(-x29 - x31 + V{3}*x32*x6 + V{1});
auto x34 = x23 - x24*(x28*x32 + x29 - x31 + V{1});
auto x35 = x7*(x22 - x33 + x34 + V{0.166666666666667});
auto x36 = V{0.5}*cell[4];
auto x37 = V{0.5}*cell[2];
auto x38 = V{3}*cell[2] - V{3}*cell[4];
auto x39 = -x25*x38;
auto x40 = x14 - V{3}*x18*x6 + x39 + V{-1};
auto x41 = x24*(-x25*x38 + V{3}*x30*x6 - x32*x9 + V{1});
auto x42 = x24*x40 + x37;
auto x43 = x7*(x36 - x41 + x42 + V{0.166666666666667});
auto x0 = -x7*((x14 + x20)*(V{0.333333333333333}*cell[0] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}) + V{1}*cell[0] + V{0.333333333333333}) + cell[0];
auto x1 = x21*(x22 - x23 + x24*(V{3}*x13*x6 - x20 - x27) - x24*(x13*x28 - x19 + x27 + V{1})) - x35 + cell[1];
auto x2 = x21*(-x24*x40 - x24*(-x14 + x18*x28 + x39 + V{1}) + x36 - x37) - x43 + cell[2];
auto x3 = -x10 - x21*(-x33 - x34 + V{0.5}*cell[3]) - x35;
auto x4 = -x15 - x21*(-x41 - x42 + V{0.5}*cell[4]) - x43;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
return { x5, V{1}*x6*(x30 + x32) };
}
 
};
 
template <typename... FIELDS>
struct TRT::type<descriptors::D2Q9<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::descriptors::OMEGA>();
auto x12 = parameters.template get<olb::collision::TRT::MAGIC>();
auto x9 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + V{1};
auto x10 = V{1} / ((x9)*(x9));
auto x13 = V{1.5}*x10;
auto x14 = -cell[7];
auto x15 = -cell[5];
auto x16 = x15 + cell[1];
auto x17 = -cell[6];
auto x18 = x17 + cell[2];
auto x19 = x14 + x16 + x18 + cell[3];
auto x20 = -x19;
auto x21 = x20*x20;
auto x22 = x13*x21;
auto x23 = -cell[4] + cell[8];
auto x24 = x16 + x23 - cell[3] + cell[7];
auto x25 = x24*x24;
auto x26 = x13*x25;
auto x27 = x26 + V{-1};
auto x28 = x22 + x27;
auto x29 = V{1} / (-x12/(V{0.5} - V{1}/x11) + V{0.5});
auto x30 = V{0.5}*cell[5];
auto x31 = V{0.5}*cell[1];
auto x32 = V{0.0138888888888889}*cell[0] + V{0.0138888888888889}*cell[1] + V{0.0138888888888889}*cell[2] + V{0.0138888888888889}*cell[3] + V{0.0138888888888889}*cell[4] + V{0.0138888888888889}*cell[5] + V{0.0138888888888889}*cell[6] + V{0.0138888888888889}*cell[7] + V{0.0138888888888889}*cell[8] + V{0.0138888888888889};
auto x33 = V{1} / (x9);
auto x34 = V{3}*cell[3];
auto x35 = V{3}*cell[1] - V{3}*cell[5];
auto x36 = x33*(-x34 + x35 - V{3}*cell[4] + V{3}*cell[7] + V{3}*cell[8]);
auto x37 = -x36;
auto x38 = x18 + x23 + V{2}*cell[1] - V{2}*cell[5];
auto x39 = -V{4.5}*x10*x38*x38;
auto x40 = x34 + x35 + V{3}*cell[2] - V{3}*cell[6] - V{3}*cell[7];
auto x41 = -x33*x40;
auto x42 = x28 + x41;
auto x43 = -x22;
auto x44 = V{4.5}*x10;
auto x45 = -x38;
auto x46 = x44*(x45*x45);
auto x47 = V{1} - x26;
auto x48 = x41 + x47;
auto x49 = x19*x19;
auto x50 = x13*x49;
auto x51 = x33*x40;
auto x52 = x27 + x51;
auto x53 = x50 + x52;
auto x54 = x32*(-x36 - x39 - x53);
auto x55 = x47 + x51;
auto x56 = x36 - x50;
auto x57 = x31 - x32*(x46 + x55 + x56);
auto x58 = x11*(x30 - x54 + x57 + V{0.0277777777777778});
auto x59 = V{0.5}*cell[6];
auto x60 = V{0.5}*cell[2];
auto x61 = V{0.0555555555555556}*cell[0] + V{0.0555555555555556}*cell[1] + V{0.0555555555555556}*cell[2] + V{0.0555555555555556}*cell[3] + V{0.0555555555555556}*cell[4] + V{0.0555555555555556}*cell[5] + V{0.0555555555555556}*cell[6] + V{0.0555555555555556}*cell[7] + V{0.0555555555555556}*cell[8] + V{0.0555555555555556};
auto x62 = V{3}*x10;
auto x63 = x61*(V{3}*x10*x49 - x52);
auto x64 = x60 - x61*(x49*x62 + x55);
auto x65 = x11*(x59 - x63 + x64 + V{0.111111111111111});
auto x66 = V{0.5}*cell[7];
auto x67 = V{0.5}*cell[3];
auto x68 = -cell[8];
auto x69 = -x18 - x68 - V{2}*cell[3] - cell[4] + V{2}*cell[7];
auto x70 = x69*x69;
auto x71 = -V{4.5}*x10*x70;
auto x72 = x36 + x42 + x71;
auto x73 = x36 + x43;
auto x74 = x32*(-x37 - x53 - x71);
auto x75 = x32*x72 + x67;
auto x76 = x11*(x66 - x74 + x75 + V{0.0277777777777778});
auto x77 = V{0.5}*cell[8];
auto x78 = V{0.5}*cell[4];
auto x79 = -V{3}*x10*x25 + x22 + x36 + V{-1};
auto x80 = x25*x62 + V{1};
auto x81 = x61*(x56 + x80);
auto x82 = x61*x79 + x78;
auto x83 = x11*(x77 - x81 + x82 + V{0.111111111111111});
auto x0 = -x11*(x28*(V{0.444444444444444}*cell[0] + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8] + V{0.444444444444444}) + V{1}*cell[0] + V{0.444444444444444}) + cell[0];
auto x1 = x29*(x30 - x31 + x32*(-x37 - x39 - x42) - x32*(x37 + x43 + x46 + x48)) - x58 + cell[1];
auto x2 = x29*(x59 - x60 - x61*(x21*x62 + x48) + x61*(V{3}*x10*x21 - x27 - x41)) - x65 + cell[2];
auto x3 = x29*(-x32*x72 - x32*(x44*x70 + x48 + x73) + x66 - x67) - x76 + cell[3];
auto x4 = x29*(-x61*x79 - x61*(x73 + x80) + x77 - x78) - x83 + cell[4];
auto x5 = -x15 - x29*(-x54 - x57 + V{0.5}*cell[5]) - x58;
auto x6 = -x17 - x29*(-x63 - x64 + V{0.5}*cell[6]) - x65;
auto x7 = -x14 - x29*(-x74 - x75 + V{0.5}*cell[7]) - x76;
auto x8 = -x29*(-x81 - x82 + V{0.5}*cell[8]) - x68 - x83;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
return { x9, V{1}*x10*(x25 + x49) };
}
 
};
 
template <typename... FIELDS>
struct TRT::type<descriptors::D3Q7<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::collision::TRT::MAGIC>();
auto x10 = parameters.template get<olb::descriptors::OMEGA>();
auto x7 = cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + V{1};
auto x8 = V{1} / ((x7)*(x7));
auto x9 = V{2}*x8;
auto x12 = -cell[4];
auto x13 = x12 + cell[1];
auto x14 = -x13;
auto x15 = x14*x14;
auto x16 = x15*x9;
auto x17 = -cell[5];
auto x18 = x17 + cell[2];
auto x19 = -x18;
auto x20 = x19*x19;
auto x21 = x20*x9;
auto x22 = -cell[6];
auto x23 = x22 + cell[3];
auto x24 = -x23;
auto x25 = x24*x24;
auto x26 = x25*x9;
auto x27 = x21 + x26 + V{-1};
auto x28 = V{1} / (-x11/(V{0.5} - V{1}/x10) + V{0.5});
auto x29 = V{0.5}*cell[4];
auto x30 = V{0.5}*cell[1];
auto x31 = V{0.0625}*cell[0] + V{0.0625}*cell[1] + V{0.0625}*cell[2] + V{0.0625}*cell[3] + V{0.0625}*cell[4] + V{0.0625}*cell[5] + V{0.0625}*cell[6] + V{0.0625};
auto x32 = V{1} / (x7);
auto x33 = V{4}*cell[1] - V{4}*cell[4];
auto x34 = -x32*x33;
auto x35 = -V{6}*x15*x8 + x27 + x34;
auto x36 = V{6}*x8;
auto x37 = -x21;
auto x38 = V{1} - x26;
auto x39 = x18*x18;
auto x40 = x39*x9;
auto x41 = x13*x13;
auto x42 = x23*x23;
auto x43 = x42*x9 + V{-1};
auto x44 = x31*(-x32*x33 - x40 + V{6}*x41*x8 - x43);
auto x45 = x30 + x31*x35;
auto x46 = x10*(x29 - x44 + x45 + V{0.125});
auto x47 = V{0.5}*cell[5];
auto x48 = V{0.5}*cell[2];
auto x49 = V{4}*cell[2] - V{4}*cell[5];
auto x50 = -x32*x49;
auto x51 = x16 + V{-1};
auto x52 = -V{6}*x20*x8 + x26 + x50 + x51;
auto x53 = -x16;
auto x54 = x41*x9;
auto x55 = x31*(-x32*x49 + V{6}*x39*x8 - x43 - x54);
auto x56 = x31*x52 + x48;
auto x57 = x10*(x47 - x55 + x56 + V{0.125});
auto x58 = V{0.5}*cell[6];
auto x59 = V{0.5}*cell[3];
auto x60 = V{4}*cell[3] - V{4}*cell[6];
auto x61 = -x32*x60;
auto x62 = x21 - V{6}*x25*x8 + x51 + x61;
auto x63 = x31*(-x32*x60 - x40 + V{6}*x42*x8 - x54 + V{1});
auto x64 = x31*x62 + x59;
auto x65 = x10*(x58 - x63 + x64 + V{0.125});
auto x0 = -x10*((x16 + x27)*(V{0.25}*cell[0] + V{0.25}*cell[1] + V{0.25}*cell[2] + V{0.25}*cell[3] + V{0.25}*cell[4] + V{0.25}*cell[5] + V{0.25}*cell[6] + V{0.25}) + V{1}*cell[0] + V{0.25}) + cell[0];
auto x1 = x28*(x29 - x30 - x31*x35 - x31*(x15*x36 + x34 + x37 + x38)) - x46 + cell[1];
auto x2 = x28*(-x31*x52 - x31*(x20*x36 + x38 + x50 + x53) + x47 - x48) - x57 + cell[2];
auto x3 = x28*(-x31*x62 - x31*(x25*x36 + x37 + x53 + x61 + V{1}) + x58 - x59) - x65 + cell[3];
auto x4 = -x12 - x28*(-x44 - x45 + V{0.5}*cell[4]) - x46;
auto x5 = -x17 - x28*(-x55 - x56 + V{0.5}*cell[5]) - x57;
auto x6 = -x22 - x28*(-x63 - x64 + V{0.5}*cell[6]) - x65;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
return { x7, V{1}*x8*(x39 + x41 + x42) };
}
 
};
 
template <typename... FIELDS>
struct TRT::type<descriptors::D3Q19<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x23 = parameters.template get<olb::collision::TRT::MAGIC>();
auto x19 = cell[10] + cell[14];
auto x20 = cell[12] + cell[7];
auto x21 = x19 + x20 + cell[0] + cell[11] + cell[13] + cell[15] + cell[16] + cell[17] + cell[18] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[8] + cell[9] + V{1};
auto x24 = V{1} / ((x21)*(x21));
auto x25 = V{1.5}*x24;
auto x26 = cell[13] - cell[4];
auto x27 = cell[15] - cell[6];
auto x28 = x26 + x27;
auto x29 = -cell[1];
auto x30 = cell[16] - cell[7];
auto x31 = x29 + x30;
auto x32 = x19 - cell[5];
auto x33 = x28 + x31 + x32;
auto x34 = x33*x33;
auto x35 = x25*x34;
auto x36 = cell[17] - cell[8];
auto x37 = x26 + x36;
auto x38 = cell[18] - cell[9];
auto x39 = -cell[14];
auto x40 = -cell[2];
auto x41 = x39 + x40 + cell[11] + cell[5];
auto x42 = x37 + x38 + x41;
auto x43 = x42*x42;
auto x44 = x25*x43;
auto x45 = x27 + x36;
auto x46 = -cell[3];
auto x47 = -cell[18];
auto x48 = x47 + cell[9];
auto x49 = x46 + x48;
auto x50 = -cell[16];
auto x51 = x20 + x50;
auto x52 = x45 + x49 + x51;
auto x53 = x52*x52;
auto x54 = x25*x53;
auto x55 = x44 + x54 + V{-1};
auto x56 = x35 + x55;
auto x57 = V{1} / (-x23/(V{0.5} - V{1}/x22) + V{0.5});
auto x58 = V{0.5}*cell[1];
auto x59 = V{0.0277777777777778}*cell[0] + V{0.0277777777777778}*cell[10] + V{0.0277777777777778}*cell[11] + V{0.0277777777777778}*cell[12] + V{0.0277777777777778}*cell[13] + V{0.0277777777777778}*cell[14] + V{0.0277777777777778}*cell[15] + V{0.0277777777777778}*cell[16] + V{0.0277777777777778}*cell[17] + V{0.0277777777777778}*cell[18] + V{0.0277777777777778}*cell[1] + V{0.0277777777777778}*cell[2] + V{0.0277777777777778}*cell[3] + V{0.0277777777777778}*cell[4] + V{0.0277777777777778}*cell[5] + V{0.0277777777777778}*cell[6] + V{0.0277777777777778}*cell[7] + V{0.0277777777777778}*cell[8] + V{0.0277777777777778}*cell[9] + V{0.0277777777777778};
auto x60 = V{1} / (x21);
auto x61 = V{3}*cell[14];
auto x62 = V{3}*cell[16];
auto x63 = V{3}*cell[5];
auto x64 = V{3}*cell[7];
auto x65 = V{3}*cell[13] - V{3}*cell[4];
auto x66 = V{3}*cell[15] - V{3}*cell[6];
auto x67 = x60*(x61 + x62 - x63 - x64 + x65 + x66 + V{3}*cell[10] - V{3}*cell[1]);
auto x68 = -V{3}*x24*x34 + x55 + x67;
auto x69 = V{3}*x24;
auto x70 = -x44;
auto x71 = V{1} - x54;
auto x72 = x70 + x71;
auto x73 = x67 + x72;
auto x74 = x59*(x34*x69 + x73);
auto x75 = -x74 + V{0.5}*cell[10];
auto x76 = x58 + x59*x68;
auto x77 = x22*(x75 + x76 + V{0.0555555555555556});
auto x78 = V{0.5}*cell[2];
auto x79 = V{3}*cell[18];
auto x80 = V{3}*cell[9];
auto x81 = V{3}*cell[17] - V{3}*cell[8];
auto x82 = x60*(-x61 + x63 + x65 + x79 - x80 + x81 + V{3}*cell[11] - V{3}*cell[2]);
auto x83 = x35 + V{-1};
auto x84 = -V{3}*x24*x43 + x54 + x82 + x83;
auto x85 = -x35;
auto x86 = x82 + x85;
auto x87 = x59*(x43*x69 + x71 + x86);
auto x88 = -x87 + V{0.5}*cell[11];
auto x89 = x59*x84 + x78;
auto x90 = x22*(x88 + x89 + V{0.0555555555555556});
auto x91 = V{0.5}*cell[3];
auto x92 = x60*(-x62 + x64 + x66 - x79 + x80 + x81 + V{3}*cell[12] - V{3}*cell[3]);
auto x93 = -V{3}*x24*x53 + x44 + x83 + x92;
auto x94 = x85 + x92;
auto x95 = x59*(x53*x69 + x70 + x94 + V{1});
auto x96 = -x95 + V{0.5}*cell[12];
auto x97 = x59*x93 + x91;
auto x98 = x22*(x96 + x97 + V{0.0555555555555556});
auto x99 = V{0.5}*cell[4];
auto x100 = V{0.0138888888888889}*cell[0] + V{0.0138888888888889}*cell[10] + V{0.0138888888888889}*cell[11] + V{0.0138888888888889}*cell[12] + V{0.0138888888888889}*cell[13] + V{0.0138888888888889}*cell[14] + V{0.0138888888888889}*cell[15] + V{0.0138888888888889}*cell[16] + V{0.0138888888888889}*cell[17] + V{0.0138888888888889}*cell[18] + V{0.0138888888888889}*cell[1] + V{0.0138888888888889}*cell[2] + V{0.0138888888888889}*cell[3] + V{0.0138888888888889}*cell[4] + V{0.0138888888888889}*cell[5] + V{0.0138888888888889}*cell[6] + V{0.0138888888888889}*cell[7] + V{0.0138888888888889}*cell[8] + V{0.0138888888888889}*cell[9] + V{0.0138888888888889};
auto x101 = x31 + cell[10];
auto x102 = x101 + x38 + x40 + x45 + cell[11] + V{2}*cell[13] - V{2}*cell[4];
auto x103 = x102*x102;
auto x104 = x56 + x67;
auto x105 = -V{4.5}*x103*x24 + x104 + x82;
auto x106 = V{4.5}*x24;
auto x107 = x100*(x103*x106 + x73 + x86);
auto x108 = -x107 + V{0.5}*cell[13];
auto x109 = x100*x105 + x99;
auto x110 = x22*(x108 + x109 + V{0.0277777777777778});
auto x111 = -x82;
auto x112 = -cell[11];
auto x113 = -cell[17];
auto x114 = x113 + cell[8];
auto x115 = x101 + x112 + x114 + x27 + x48 + V{2}*cell[14] + cell[2] - V{2}*cell[5];
auto x116 = -x115;
auto x117 = x104 + x111 - V{4.5}*x24*x116*x116;
auto x118 = x56 - x67;
auto x119 = x118 - V{4.5}*x24*x115*x115 + x82;
auto x120 = V{0.5}*cell[14];
auto x121 = V{0.5}*cell[5];
auto x122 = x120 - x121;
auto x123 = x100*x119;
auto x124 = x100*x117;
auto x125 = x22*(x120 + x121 + x123 + x124 + V{0.0277777777777778});
auto x126 = V{0.5}*cell[6];
auto x127 = x29 + x32;
auto x128 = x127 + x37 + x49 + cell[12] + V{2}*cell[15] - V{2}*cell[6];
auto x129 = x128*x128;
auto x130 = x104 - V{4.5}*x129*x24 + x92;
auto x131 = x100*(x106*x129 + x73 + x94);
auto x132 = -x131 + V{0.5}*cell[15];
auto x133 = x100*x130 + x126;
auto x134 = x22*(x132 + x133 + V{0.0277777777777778});
auto x135 = -x92;
auto x136 = -cell[12];
auto x137 = x136 + x26 + cell[3];
auto x138 = x114 + x127 + x137 + x38 + V{2}*cell[16] - V{2}*cell[7];
auto x139 = -x138;
auto x140 = x104 + x135 - V{4.5}*x24*x139*x139;
auto x141 = x118 - V{4.5}*x24*x138*x138 + x92;
auto x142 = V{0.5}*cell[16];
auto x143 = V{0.5}*cell[7];
auto x144 = x142 - x143;
auto x145 = x100*x141;
auto x146 = x100*x140;
auto x147 = x22*(x142 + x143 + x145 + x146 + V{0.0277777777777778});
auto x148 = V{0.5}*cell[8];
auto x149 = x28 + x41 + x46 + x51 + V{2}*cell[17] - V{2}*cell[8];
auto x150 = x149*x149;
auto x151 = x56 + x82;
auto x152 = -V{4.5}*x150*x24 + x151 + x92;
auto x153 = x100*(x106*x150 + x72 + x86 + x92);
auto x154 = -x153 + V{0.5}*cell[17];
auto x155 = x100*x152 + x148;
auto x156 = x22*(x154 + x155 + V{0.0277777777777778});
auto x157 = -cell[15];
auto x158 = x137 + x157 + x30 + x41 + V{2}*cell[18] + cell[6] - V{2}*cell[9];
auto x159 = -x158;
auto x160 = x135 + x151 - V{4.5}*x24*x159*x159;
auto x161 = x111 - V{4.5}*x24*x158*x158 + x56 + x92;
auto x162 = V{0.5}*cell[18];
auto x163 = V{0.5}*cell[9];
auto x164 = x162 - x163;
auto x165 = x100*x160;
auto x166 = x100*x161;
auto x167 = x22*(x162 + x163 + x165 + x166 + V{0.0277777777777778});
auto x0 = -x22*(x56*(V{0.333333333333333}*cell[0] + V{0.333333333333333}*cell[10] + V{0.333333333333333}*cell[11] + V{0.333333333333333}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9] + V{0.333333333333333}) + V{1}*cell[0] + V{0.333333333333333}) + cell[0];
auto x1 = x57*(-x58 - x59*x68 + x75) - x77 + cell[1];
auto x2 = x57*(-x59*x84 - x78 + x88) - x90 + cell[2];
auto x3 = x57*(-x59*x93 - x91 + x96) - x98 + cell[3];
auto x4 = -x110 + x57*(-x100*x105 + x108 - x99) + cell[4];
auto x5 = -x125 + x57*(-x100*x117 + x100*x119 + x122) + cell[5];
auto x6 = -x134 + x57*(-x100*x130 - x126 + x132) + cell[6];
auto x7 = -x147 + x57*(-x100*x140 + x100*x141 + x144) + cell[7];
auto x8 = -x156 + x57*(-x100*x152 - x148 + x154) + cell[8];
auto x9 = -x167 + x57*(-x100*x160 + x100*x161 + x164) + cell[9];
auto x10 = -x57*(-x74 - x76 + V{0.5}*cell[10]) - x77 + cell[10];
auto x11 = -x112 - x57*(-x87 - x89 + V{0.5}*cell[11]) - x90;
auto x12 = -x136 - x57*(-x95 - x97 + V{0.5}*cell[12]) - x98;
auto x13 = -x110 - x57*(-x107 - x109 + V{0.5}*cell[13]) + cell[13];
auto x14 = -x125 - x39 - x57*(x122 + x123 - x124);
auto x15 = -x134 - x157 - x57*(-x131 - x133 + V{0.5}*cell[15]);
auto x16 = -x147 - x50 - x57*(x144 + x145 - x146);
auto x17 = -x113 - x156 - x57*(-x153 - x155 + V{0.5}*cell[17]);
auto x18 = -x167 - x47 - x57*(x164 - x165 + x166);
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { x21, V{1}*x24*(x34 + x43 + x53) };
}
 
};
 
template <typename... FIELDS>
struct TRT::type<descriptors::D3Q27<FIELDS...>,momenta::BulkTuple,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x31 = parameters.template get<olb::collision::TRT::MAGIC>();
auto x30 = parameters.template get<olb::descriptors::OMEGA>();
auto x27 = cell[8] + cell[9];
auto x28 = cell[15] + cell[21];
auto x29 = cell[11] + cell[26];
auto x32 = x27 + x28 + x29 + cell[0] + cell[10] + cell[12] + cell[13] + cell[14] + cell[16] + cell[17] + cell[18] + cell[19] + cell[1] + cell[20] + cell[22] + cell[23] + cell[24] + cell[25] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + V{1};
auto x33 = V{1} / ((x32)*(x32));
auto x34 = V{1.5}*x33;
auto x35 = -cell[17];
auto x36 = -cell[19];
auto x37 = x35 + x36 + cell[4] + cell[6];
auto x38 = -cell[24];
auto x39 = -cell[23];
auto x40 = x39 + cell[10];
auto x41 = x38 + x40 + cell[11];
auto x42 = -cell[25];
auto x43 = x42 + cell[12];
auto x44 = -cell[14];
auto x45 = -cell[20];
auto x46 = x45 + cell[7];
auto x47 = x44 + x46 + cell[1];
auto x48 = -cell[18];
auto x49 = x48 + cell[5];
auto x50 = -cell[26];
auto x51 = x50 + cell[13];
auto x52 = x37 + x41 + x43 + x47 + x49 + x51;
auto x53 = -x52;
auto x54 = x53*x53;
auto x55 = x34*x54;
auto x56 = -cell[21];
auto x57 = -cell[13];
auto x58 = x56 + x57 + cell[26] + cell[8];
auto x59 = -cell[22];
auto x60 = x35 + cell[4];
auto x61 = x59 + x60 + cell[9];
auto x62 = -cell[15];
auto x63 = x62 + cell[18] + cell[2] - cell[5];
auto x64 = -cell[12] + cell[25];
auto x65 = x41 + x58 + x61 + x63 + x64;
auto x66 = -x65;
auto x67 = x66*x66;
auto x68 = x34*x67;
auto x69 = -cell[16];
auto x70 = x43 + x69 + cell[3];
auto x71 = -cell[9];
auto x72 = x36 + cell[6];
auto x73 = x71 + x72 + cell[22];
auto x74 = cell[20] - cell[7];
auto x75 = x40 - cell[11] + cell[24];
auto x76 = x58 + x70 + x73 + x74 + x75;
auto x77 = -x76;
auto x78 = x77*x77;
auto x79 = x34*x78;
auto x80 = x68 + x79 + V{-1};
auto x81 = x55 + x80;
auto x82 = V{1} / (-x31/(V{0.5} - V{1}/x30) + V{0.5});
auto x83 = V{0.5}*cell[14];
auto x84 = V{0.5}*cell[1];
auto x85 = V{0.037037037037037}*cell[0] + V{0.037037037037037}*cell[10] + V{0.037037037037037}*cell[11] + V{0.037037037037037}*cell[12] + V{0.037037037037037}*cell[13] + V{0.037037037037037}*cell[14] + V{0.037037037037037}*cell[15] + V{0.037037037037037}*cell[16] + V{0.037037037037037}*cell[17] + V{0.037037037037037}*cell[18] + V{0.037037037037037}*cell[19] + V{0.037037037037037}*cell[1] + V{0.037037037037037}*cell[20] + V{0.037037037037037}*cell[21] + V{0.037037037037037}*cell[22] + V{0.037037037037037}*cell[23] + V{0.037037037037037}*cell[24] + V{0.037037037037037}*cell[25] + V{0.037037037037037}*cell[26] + V{0.037037037037037}*cell[2] + V{0.037037037037037}*cell[3] + V{0.037037037037037}*cell[4] + V{0.037037037037037}*cell[5] + V{0.037037037037037}*cell[6] + V{0.037037037037037}*cell[7] + V{0.037037037037037}*cell[8] + V{0.037037037037037}*cell[9] + V{0.037037037037037};
auto x86 = V{1} / (x32);
auto x87 = V{3}*cell[5];
auto x88 = V{3}*cell[7];
auto x89 = V{3}*cell[13];
auto x90 = V{3}*cell[18];
auto x91 = V{3}*cell[20];
auto x92 = V{3}*cell[26];
auto x93 = V{3}*cell[10];
auto x94 = V{3}*cell[11];
auto x95 = -V{3}*cell[23];
auto x96 = V{3}*cell[24];
auto x97 = x93 + x94 + x95 - x96 - V{3}*cell[17] + V{3}*cell[4];
auto x98 = V{3}*cell[12];
auto x99 = V{3}*cell[25];
auto x100 = x98 - x99 - V{3}*cell[19] + V{3}*cell[6];
auto x101 = x100 + x87 + x88 + x89 - x90 - x91 - x92 + x97 - V{3}*cell[14] + V{3}*cell[1];
auto x102 = -x101*x86;
auto x103 = x102 - V{3}*x33*x54 + x80;
auto x104 = V{3}*x33;
auto x105 = -x68;
auto x106 = V{1} - x79;
auto x107 = x105 + x106;
auto x108 = x102 + x107;
auto x109 = x52*x52;
auto x110 = x101*x86;
auto x111 = x65*x65;
auto x112 = x111*x34;
auto x113 = x76*x76;
auto x114 = x113*x34 + V{-1};
auto x115 = x112 + x114;
auto x116 = x110 + x115;
auto x117 = x85*(V{3}*x109*x33 - x116);
auto x118 = x103*x85 + x84;
auto x119 = x30*(-x117 + x118 + x83 + V{0.0740740740740741});
auto x120 = V{0.5}*cell[15];
auto x121 = V{0.5}*cell[2];
auto x122 = V{3}*cell[9];
auto x123 = V{3}*cell[22];
auto x124 = -x89 + x92 - V{3}*cell[21] + V{3}*cell[8];
auto x125 = x122 - x123 + x124 - x87 + x90 + x97 - x98 + x99 - V{3}*cell[15] + V{3}*cell[2];
auto x126 = -x125*x86;
auto x127 = x55 + V{-1};
auto x128 = x126 + x127 - V{3}*x33*x67 + x79;
auto x129 = -x55;
auto x130 = x126 + x129;
auto x131 = x125*x86;
auto x132 = x109*x34;
auto x133 = x131 + x132;
auto x134 = x85*(V{3}*x111*x33 - x114 - x133);
auto x135 = x121 + x128*x85;
auto x136 = x30*(x120 - x134 + x135 + V{0.0740740740740741});
auto x137 = V{0.5}*cell[16];
auto x138 = V{0.5}*cell[3];
auto x139 = x100 - x122 + x123 + x124 - x88 + x91 + x93 - x94 + x95 + x96 - V{3}*cell[16] + V{3}*cell[3];
auto x140 = -x139*x86;
auto x141 = x127 + x140 - V{3}*x33*x78 + x68;
auto x142 = x129 + x140;
auto x143 = x139*x86;
auto x144 = x132 + x143;
auto x145 = x85*(-x112 + V{3}*x113*x33 - x144 + V{1});
auto x146 = x138 + x141*x85;
auto x147 = x30*(x137 - x145 + x146 + V{0.0740740740740741});
auto x148 = V{0.5}*cell[17];
auto x149 = V{0.5}*cell[4];
auto x150 = V{0.00925925925925926}*cell[0] + V{0.00925925925925926}*cell[10] + V{0.00925925925925926}*cell[11] + V{0.00925925925925926}*cell[12] + V{0.00925925925925926}*cell[13] + V{0.00925925925925926}*cell[14] + V{0.00925925925925926}*cell[15] + V{0.00925925925925926}*cell[16] + V{0.00925925925925926}*cell[17] + V{0.00925925925925926}*cell[18] + V{0.00925925925925926}*cell[19] + V{0.00925925925925926}*cell[1] + V{0.00925925925925926}*cell[20] + V{0.00925925925925926}*cell[21] + V{0.00925925925925926}*cell[22] + V{0.00925925925925926}*cell[23] + V{0.00925925925925926}*cell[24] + V{0.00925925925925926}*cell[25] + V{0.00925925925925926}*cell[26] + V{0.00925925925925926}*cell[2] + V{0.00925925925925926}*cell[3] + V{0.00925925925925926}*cell[4] + V{0.00925925925925926}*cell[5] + V{0.00925925925925926}*cell[6] + V{0.00925925925925926}*cell[7] + V{0.00925925925925926}*cell[8] + V{0.00925925925925926}*cell[9] + V{0.00925925925925926};
auto x151 = V{2}*cell[11] - V{2}*cell[24];
auto x152 = V{2}*cell[10] - V{2}*cell[23];
auto x153 = x152 + x56;
auto x154 = x62 + cell[2];
auto x155 = x154 - V{2}*cell[17] + V{2}*cell[4];
auto x156 = x151 + x153 + x155 + x27 + x47 + x59 + x72;
auto x157 = -x156;
auto x158 = x157*x157;
auto x159 = x102 + x81;
auto x160 = x126 + x159;
auto x161 = -V{4.5}*x158*x33 + x160;
auto x162 = V{4.5}*x33;
auto x163 = x108 + x130;
auto x164 = x116 + x133;
auto x165 = -x150*(x164 - V{4.5}*x33*x156*x156);
auto x166 = x149 + x150*x161;
auto x167 = x30*(x148 - x165 + x166 + V{0.0185185185185185});
auto x168 = V{2}*cell[25];
auto x169 = V{2}*cell[12];
auto x170 = -x168 + x169;
auto x171 = V{2}*cell[26];
auto x172 = V{2}*cell[13];
auto x173 = -x171 + x172 - cell[8];
auto x174 = V{2}*cell[18];
auto x175 = V{2}*cell[5];
auto x176 = -x174 + x175 - cell[2];
auto x177 = x170 + x173 + x176 + x28 + x47 + x73;
auto x178 = -x126;
auto x179 = x159 + x178;
auto x180 = x179 - V{4.5}*x33*x177*x177;
auto x181 = -x177;
auto x182 = -x102 + x81;
auto x183 = x126 + x182;
auto x184 = x183 - V{4.5}*x33*x181*x181;
auto x185 = V{0.5}*cell[18];
auto x186 = V{0.5}*cell[5];
auto x187 = x185 - x186;
auto x188 = x150*x184;
auto x189 = x150*x180;
auto x190 = x30*(x185 + x186 + x188 + x189 + V{0.0185185185185185});
auto x191 = V{0.5}*cell[19];
auto x192 = V{0.5}*cell[6];
auto x193 = x44 + cell[1];
auto x194 = x193 + x49;
auto x195 = x69 + cell[3];
auto x196 = -V{2}*cell[19] + V{2}*cell[6];
auto x197 = x195 + x196;
auto x198 = x153 + x170 + x194 + x197 + x60 + x71 + cell[22] + cell[8];
auto x199 = -x198;
auto x200 = x199*x199;
auto x201 = x140 + x159 - V{4.5}*x200*x33;
auto x202 = x108 + x142;
auto x203 = x116 + x144;
auto x204 = -x150*(x203 - V{4.5}*x33*x198*x198);
auto x205 = x150*x201 + x192;
auto x206 = x30*(x191 - x204 + x205 + V{0.0185185185185185});
auto x207 = -x140;
auto x208 = -cell[3];
auto x209 = x151 + x208 + cell[16];
auto x210 = V{2}*cell[20];
auto x211 = V{2}*cell[7];
auto x212 = -x210 + x211;
auto x213 = x173 + x194 + x209 + x212 + x61 + cell[21];
auto x214 = x159 + x207 - V{4.5}*x33*x213*x213;
auto x215 = -x213;
auto x216 = x140 + x182 - V{4.5}*x33*x215*x215;
auto x217 = V{0.5}*cell[20];
auto x218 = V{0.5}*cell[7];
auto x219 = x217 - x218;
auto x220 = x150*x216;
auto x221 = x150*x214;
auto x222 = x30*(x217 + x218 + x220 + x221 + V{0.0185185185185185});
auto x223 = V{0.5}*cell[21];
auto x224 = V{0.5}*cell[8];
auto x225 = -V{2}*cell[21] + V{2}*cell[8];
auto x226 = x195 + x225;
auto x227 = x152 + x171 - x172 + x226 + x37 + x63 + x74;
auto x228 = -x227;
auto x229 = x228*x228;
auto x230 = x126 + x81;
auto x231 = x140 - V{4.5}*x229*x33 + x230;
auto x232 = x115 + x133 + x143;
auto x233 = -x150*(x232 - V{4.5}*x33*x227*x227);
auto x234 = x150*x231 + x224;
auto x235 = x30*(x223 - x233 + x234 + V{0.0185185185185185});
auto x236 = V{2}*cell[22];
auto x237 = V{2}*cell[9];
auto x238 = -x236 + x237;
auto x239 = x168 - x169 + x209 + x238 + x46 + x60 + x63 + cell[19] - cell[6];
auto x240 = x207 + x230 - V{4.5}*x33*x239*x239;
auto x241 = -x239;
auto x242 = x140 + x178 - V{4.5}*x33*x241*x241 + x81;
auto x243 = V{0.5}*cell[22];
auto x244 = V{0.5}*cell[9];
auto x245 = x243 - x244;
auto x246 = x150*x240;
auto x247 = x150*x242;
auto x248 = x30*(x243 + x244 + x246 + x247 + V{0.0185185185185185});
auto x249 = V{0.5}*cell[23];
auto x250 = V{0.5}*cell[10];
auto x251 = V{0.00231481481481481}*cell[0] + V{0.00231481481481481}*cell[10] + V{0.00231481481481481}*cell[11] + V{0.00231481481481481}*cell[12] + V{0.00231481481481481}*cell[13] + V{0.00231481481481481}*cell[14] + V{0.00231481481481481}*cell[15] + V{0.00231481481481481}*cell[16] + V{0.00231481481481481}*cell[17] + V{0.00231481481481481}*cell[18] + V{0.00231481481481481}*cell[19] + V{0.00231481481481481}*cell[1] + V{0.00231481481481481}*cell[20] + V{0.00231481481481481}*cell[21] + V{0.00231481481481481}*cell[22] + V{0.00231481481481481}*cell[23] + V{0.00231481481481481}*cell[24] + V{0.00231481481481481}*cell[25] + V{0.00231481481481481}*cell[26] + V{0.00231481481481481}*cell[2] + V{0.00231481481481481}*cell[3] + V{0.00231481481481481}*cell[4] + V{0.00231481481481481}*cell[5] + V{0.00231481481481481}*cell[6] + V{0.00231481481481481}*cell[7] + V{0.00231481481481481}*cell[8] + V{0.00231481481481481}*cell[9] + V{0.00231481481481481};
auto x252 = x155 + x193;
auto x253 = x196 + x225 + x252 + x29 + x38 + x57 + x70 + V{3}*cell[10] - V{3}*cell[23];
auto x254 = -x253;
auto x255 = x254*x254;
auto x256 = x140 + x160 - V{4.5}*x255*x33;
auto x257 = -x251*(x143 + x164 - V{4.5}*x33*x253*x253);
auto x258 = x250 + x251*x256;
auto x259 = x30*(x249 - x257 + x258 + V{0.00462962962962963});
auto x260 = V{0.5}*cell[24];
auto x261 = V{0.5}*cell[11];
auto x262 = x208 + x212 + x238 + x252 + x40 + x51 + x64 + V{3}*cell[11] + cell[16] - V{3}*cell[24];
auto x263 = x160 + x207 - V{4.5}*x33*x262*x262;
auto x264 = -x262;
auto x265 = x264*x264;
auto x266 = x251*(x143 - x164 + V{4.5}*x265*x33);
auto x267 = x251*x263 + x261;
auto x268 = x30*(x260 - x266 + x267 + V{0.00462962962962963});
auto x269 = V{0.5}*cell[25];
auto x270 = V{0.5}*cell[12];
auto x271 = x176 + x193 + x197 + x236 - x237 + x51 + x75 + V{3}*cell[12] + cell[15] - V{3}*cell[25];
auto x272 = x140 + x179 - V{4.5}*x33*x271*x271;
auto x273 = -x271;
auto x274 = x273*x273;
auto x275 = x251*(x131 - x203 + V{4.5}*x274*x33);
auto x276 = x251*x272 + x270;
auto x277 = x30*(x269 - x275 + x276 + V{0.00462962962962963});
auto x278 = x154 + x174 - x175 + x210 - x211 + x226 + x64 + x75 - V{3}*cell[13] + cell[14] - cell[1] + V{3}*cell[26];
auto x279 = -x278;
auto x280 = -V{4.5}*x33*x279*x279;
auto x281 = x140 + x183 - V{4.5}*x33*x278*x278;
auto x282 = V{0.5}*cell[26];
auto x283 = V{0.5}*cell[13];
auto x284 = x282 - x283;
auto x285 = x251*x281;
auto x286 = x251*(x110 - x232 - x280);
auto x287 = x30*(x282 + x283 + x285 - x286 + V{0.00462962962962963});
auto x0 = -x30*(x81*(V{0.296296296296296}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9] + V{0.296296296296296}) + V{1}*cell[0] + V{0.296296296296296}) + cell[0];
auto x1 = -x119 + x82*(-x103*x85 + x83 - x84 - x85*(x104*x54 + x108)) + cell[1];
auto x2 = -x136 + x82*(x120 - x121 - x128*x85 - x85*(x104*x67 + x106 + x130)) + cell[2];
auto x3 = -x147 + x82*(x137 - x138 - x141*x85 - x85*(x104*x78 + x105 + x142 + V{1})) + cell[3];
auto x4 = -x167 + x82*(x148 - x149 - x150*x161 - x150*(x158*x162 + x163)) + cell[4];
auto x5 = -x190 + x82*(-x150*x180 + x150*x184 + x187) + cell[5];
auto x6 = -x206 + x82*(-x150*x201 - x150*(x162*x200 + x202) + x191 - x192) + cell[6];
auto x7 = -x222 + x82*(-x150*x214 + x150*x216 + x219) + cell[7];
auto x8 = -x235 + x82*(-x150*x231 - x150*(x107 + x130 + x140 + x162*x229) + x223 - x224) + cell[8];
auto x9 = -x248 + x82*(-x150*x240 + x150*x242 + x245) + cell[9];
auto x10 = -x259 + x82*(x249 - x250 - x251*x256 - x251*(x140 + x162*x255 + x163)) + cell[10];
auto x11 = -x268 + x82*(-x251*x263 - x251*(x162*x265 + x163 + x207) + x260 - x261) + cell[11];
auto x12 = -x277 + x82*(-x251*x272 - x251*(x162*x274 + x178 + x202) + x269 - x270) + cell[12];
auto x13 = -x287 + x82*(x251*x281 + x251*(-x179 - x207 - x280) + x284) + cell[13];
auto x14 = -x119 - x44 - x82*(-x117 - x118 + V{0.5}*cell[14]);
auto x15 = -x136 - x62 - x82*(-x134 - x135 + V{0.5}*cell[15]);
auto x16 = -x147 - x69 - x82*(-x145 - x146 + V{0.5}*cell[16]);
auto x17 = -x167 - x35 - x82*(-x165 - x166 + V{0.5}*cell[17]);
auto x18 = -x190 - x48 - x82*(x187 + x188 - x189);
auto x19 = -x206 - x36 - x82*(-x204 - x205 + V{0.5}*cell[19]);
auto x20 = -x222 - x45 - x82*(x219 + x220 - x221);
auto x21 = -x235 - x56 - x82*(-x233 - x234 + V{0.5}*cell[21]);
auto x22 = -x248 - x59 - x82*(x245 - x246 + x247);
auto x23 = -x259 - x39 - x82*(-x257 - x258 + V{0.5}*cell[23]);
auto x24 = -x268 - x38 - x82*(-x266 - x267 + V{0.5}*cell[24]);
auto x25 = -x277 - x42 - x82*(-x275 - x276 + V{0.5}*cell[25]);
auto x26 = -x287 - x50 - x82*(x284 + x285 + x286);
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
cell[19] = x19;
cell[20] = x20;
cell[21] = x21;
cell[22] = x22;
cell[23] = x23;
cell[24] = x24;
cell[25] = x25;
cell[26] = x26;
return { x32, V{1}*x33*(x109 + x111 + x113) };
}
 
};
 
 
template <typename... FIELDS>
struct Poisson::type<descriptors::D2Q5<FIELDS...>,momenta::PoissonTuple,equilibria::ZerothOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x8 = parameters.template get<olb::collision::Poisson::SINK>();
auto x7 = parameters.template get<olb::descriptors::OMEGA>();
auto x5 = V{0.166666666666667}*cell[2];
auto x6 = V{0.166666666666667}*cell[0];
auto x9 = V{0.166666666666667}*cell[3];
auto x10 = V{0.166666666666667}*cell[4];
auto x11 = x10 + x6 + x9;
auto x12 = V{0.166666666666667}*cell[1];
auto x13 = x12 + x5 + x6;
auto x0 = x7*(-V{0.666666666666667}*cell[0] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4]) - x8*(cell[0] + V{0.333333333333333}) + cell[0];
auto x1 = x7*(x11 + x5 - V{0.833333333333333}*cell[1]) - x8*(cell[1] + V{0.166666666666667}) + cell[1];
auto x2 = x7*(x11 + x12 - V{0.833333333333333}*cell[2]) - x8*(cell[2] + V{0.166666666666667}) + cell[2];
auto x3 = x7*(x10 + x13 - V{0.833333333333333}*cell[3]) - x8*(cell[3] + V{0.166666666666667}) + cell[3];
auto x4 = x7*(x13 + x9 - V{0.833333333333333}*cell[4]) - x8*(cell[4] + V{0.166666666666667}) + cell[4];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
return { cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + V{1}, V{0} };
}
 
};
 
template <typename... FIELDS>
struct Poisson::type<descriptors::D2Q9<FIELDS...>,momenta::PoissonTuple,equilibria::ZerothOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::descriptors::OMEGA>();
auto x12 = parameters.template get<olb::collision::Poisson::SINK>();
auto x9 = V{0.0277777777777778}*cell[3];
auto x10 = V{0.0277777777777778}*cell[0];
auto x13 = V{0.0277777777777778}*cell[2];
auto x14 = V{0.0277777777777778}*cell[4];
auto x15 = V{0.0277777777777778}*cell[5];
auto x16 = V{0.0277777777777778}*cell[6];
auto x17 = V{0.0277777777777778}*cell[7];
auto x18 = V{0.0277777777777778}*cell[8];
auto x19 = x10 + x13 + x14 + x15 + x16 + x17 + x18;
auto x20 = V{0.111111111111111}*cell[4];
auto x21 = V{0.111111111111111}*cell[0];
auto x22 = V{0.111111111111111}*cell[1];
auto x23 = V{0.111111111111111}*cell[3];
auto x24 = V{0.111111111111111}*cell[5];
auto x25 = V{0.111111111111111}*cell[6];
auto x26 = V{0.111111111111111}*cell[7];
auto x27 = V{0.111111111111111}*cell[8];
auto x28 = x21 + x22 + x23 + x24 + x25 + x26 + x27;
auto x29 = V{0.0277777777777778}*cell[1];
auto x30 = V{0.111111111111111}*cell[2];
auto x31 = x10 + x13 + x14 + x16 + x18 + x29 + x9;
auto x32 = x20 + x21 + x22 + x23 + x24 + x26 + x30;
auto x0 = x11*(-V{0.555555555555556}*cell[0] + V{0.444444444444444}*cell[1] + V{0.444444444444444}*cell[2] + V{0.444444444444444}*cell[3] + V{0.444444444444444}*cell[4] + V{0.444444444444444}*cell[5] + V{0.444444444444444}*cell[6] + V{0.444444444444444}*cell[7] + V{0.444444444444444}*cell[8]) - x12*(cell[0] + V{0.444444444444444}) + cell[0];
auto x1 = x11*(x19 + x9 - V{0.972222222222222}*cell[1]) - x12*(cell[1] + V{0.0277777777777778}) + cell[1];
auto x2 = x11*(x20 + x28 - V{0.888888888888889}*cell[2]) - x12*(cell[2] + V{0.111111111111111}) + cell[2];
auto x3 = x11*(x19 + x29 - V{0.972222222222222}*cell[3]) - x12*(cell[3] + V{0.0277777777777778}) + cell[3];
auto x4 = x11*(x28 + x30 - V{0.888888888888889}*cell[4]) - x12*(cell[4] + V{0.111111111111111}) + cell[4];
auto x5 = x11*(x17 + x31 - V{0.972222222222222}*cell[5]) - x12*(cell[5] + V{0.0277777777777778}) + cell[5];
auto x6 = x11*(x27 + x32 - V{0.888888888888889}*cell[6]) - x12*(cell[6] + V{0.111111111111111}) + cell[6];
auto x7 = x11*(x15 + x31 - V{0.972222222222222}*cell[7]) - x12*(cell[7] + V{0.0277777777777778}) + cell[7];
auto x8 = x11*(x25 + x32 - V{0.888888888888889}*cell[8]) - x12*(cell[8] + V{0.111111111111111}) + cell[8];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
return { cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + V{1}, V{0} };
}
 
};
 
template <typename... FIELDS>
struct Poisson::type<descriptors::D3Q7<FIELDS...>,momenta::PoissonTuple,equilibria::ZerothOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x11 = parameters.template get<olb::collision::Poisson::SINK>();
auto x10 = parameters.template get<olb::descriptors::OMEGA>();
auto x7 = V{0.125}*cell[2];
auto x8 = V{0.125}*cell[0];
auto x9 = V{0.125}*cell[3];
auto x12 = V{0.125}*cell[4];
auto x13 = V{0.125}*cell[5];
auto x14 = V{0.125}*cell[6];
auto x15 = x12 + x13 + x14 + x8 + x9;
auto x16 = V{0.125}*cell[1];
auto x17 = x13 + x14 + x16 + x7 + x8;
auto x18 = x12 + x16 + x7 + x8 + x9;
auto x0 = x10*(-V{0.75}*cell[0] + V{0.25}*cell[1] + V{0.25}*cell[2] + V{0.25}*cell[3] + V{0.25}*cell[4] + V{0.25}*cell[5] + V{0.25}*cell[6]) - x11*(cell[0] + V{0.25}) + cell[0];
auto x1 = x10*(x15 + x7 - V{0.875}*cell[1]) - x11*(cell[1] + V{0.125}) + cell[1];
auto x2 = x10*(x15 + x16 - V{0.875}*cell[2]) - x11*(cell[2] + V{0.125}) + cell[2];
auto x3 = x10*(x12 + x17 - V{0.875}*cell[3]) - x11*(cell[3] + V{0.125}) + cell[3];
auto x4 = x10*(x17 + x9 - V{0.875}*cell[4]) - x11*(cell[4] + V{0.125}) + cell[4];
auto x5 = x10*(x14 + x18 - V{0.875}*cell[5]) - x11*(cell[5] + V{0.125}) + cell[5];
auto x6 = x10*(x13 + x18 - V{0.875}*cell[6]) - x11*(cell[6] + V{0.125}) + cell[6];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
return { cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + V{1}, V{0} };
}
 
};
 
template <typename... FIELDS>
struct Poisson::type<descriptors::D3Q19<FIELDS...>,momenta::PoissonTuple,equilibria::ZerothOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x23 = parameters.template get<olb::collision::Poisson::SINK>();
auto x19 = V{0.0555555555555556}*cell[2];
auto x20 = V{0.0555555555555556}*cell[0];
auto x21 = V{0.0555555555555556}*cell[3];
auto x24 = V{0.0555555555555556}*cell[4];
auto x25 = V{0.0555555555555556}*cell[5];
auto x26 = V{0.0555555555555556}*cell[6];
auto x27 = V{0.0555555555555556}*cell[7];
auto x28 = V{0.0555555555555556}*cell[8];
auto x29 = V{0.0555555555555556}*cell[9];
auto x30 = V{0.0555555555555556}*cell[10];
auto x31 = V{0.0555555555555556}*cell[11];
auto x32 = V{0.0555555555555556}*cell[12];
auto x33 = V{0.0555555555555556}*cell[13];
auto x34 = V{0.0555555555555556}*cell[14];
auto x35 = V{0.0555555555555556}*cell[15];
auto x36 = V{0.0555555555555556}*cell[16];
auto x37 = V{0.0555555555555556}*cell[17];
auto x38 = V{0.0555555555555556}*cell[18];
auto x39 = x20 + x21 + x24 + x25 + x26 + x27 + x28 + x29 + x30 + x31 + x32 + x33 + x34 + x35 + x36 + x37 + x38;
auto x40 = V{0.0555555555555556}*cell[1];
auto x41 = x19 + x20 + x24 + x25 + x26 + x27 + x28 + x29 + x31 + x32 + x33 + x34 + x35 + x36 + x37 + x38 + x40;
auto x42 = V{0.0277777777777778}*cell[5];
auto x43 = V{0.0277777777777778}*cell[0];
auto x44 = V{0.0277777777777778}*cell[1];
auto x45 = V{0.0277777777777778}*cell[2];
auto x46 = V{0.0277777777777778}*cell[3];
auto x47 = V{0.0277777777777778}*cell[6];
auto x48 = V{0.0277777777777778}*cell[7];
auto x49 = V{0.0277777777777778}*cell[8];
auto x50 = V{0.0277777777777778}*cell[9];
auto x51 = V{0.0277777777777778}*cell[10];
auto x52 = V{0.0277777777777778}*cell[11];
auto x53 = V{0.0277777777777778}*cell[12];
auto x54 = V{0.0277777777777778}*cell[13];
auto x55 = V{0.0277777777777778}*cell[14];
auto x56 = V{0.0277777777777778}*cell[15];
auto x57 = V{0.0277777777777778}*cell[16];
auto x58 = V{0.0277777777777778}*cell[17];
auto x59 = V{0.0277777777777778}*cell[18];
auto x60 = x43 + x44 + x45 + x46 + x47 + x48 + x49 + x50 + x51 + x52 + x53 + x54 + x55 + x56 + x57 + x58 + x59;
auto x61 = V{0.0277777777777778}*cell[4];
auto x62 = x42 + x43 + x44 + x45 + x46 + x49 + x50 + x51 + x52 + x53 + x54 + x55 + x56 + x57 + x58 + x59 + x61;
auto x63 = x42 + x43 + x44 + x45 + x46 + x47 + x48 + x51 + x52 + x53 + x54 + x55 + x56 + x57 + x58 + x59 + x61;
auto x64 = x19 + x20 + x21 + x24 + x25 + x26 + x27 + x28 + x29 + x30 + x33 + x34 + x35 + x36 + x37 + x38 + x40;
auto x65 = x42 + x43 + x44 + x45 + x46 + x47 + x48 + x49 + x50 + x51 + x52 + x53 + x56 + x57 + x58 + x59 + x61;
auto x66 = x42 + x43 + x44 + x45 + x46 + x47 + x48 + x49 + x50 + x51 + x52 + x53 + x54 + x55 + x58 + x59 + x61;
auto x67 = x42 + x43 + x44 + x45 + x46 + x47 + x48 + x49 + x50 + x51 + x52 + x53 + x54 + x55 + x56 + x57 + x61;
auto x0 = x22*(-V{0.666666666666667}*cell[0] + V{0.333333333333333}*cell[10] + V{0.333333333333333}*cell[11] + V{0.333333333333333}*cell[12] + V{0.333333333333333}*cell[13] + V{0.333333333333333}*cell[14] + V{0.333333333333333}*cell[15] + V{0.333333333333333}*cell[16] + V{0.333333333333333}*cell[17] + V{0.333333333333333}*cell[18] + V{0.333333333333333}*cell[1] + V{0.333333333333333}*cell[2] + V{0.333333333333333}*cell[3] + V{0.333333333333333}*cell[4] + V{0.333333333333333}*cell[5] + V{0.333333333333333}*cell[6] + V{0.333333333333333}*cell[7] + V{0.333333333333333}*cell[8] + V{0.333333333333333}*cell[9]) - x23*(cell[0] + V{0.333333333333333}) + cell[0];
auto x1 = x22*(x19 + x39 - V{0.944444444444444}*cell[1]) - x23*(cell[1] + V{0.0555555555555556}) + cell[1];
auto x2 = x22*(x39 + x40 - V{0.944444444444444}*cell[2]) - x23*(cell[2] + V{0.0555555555555556}) + cell[2];
auto x3 = x22*(x30 + x41 - V{0.944444444444444}*cell[3]) - x23*(cell[3] + V{0.0555555555555556}) + cell[3];
auto x4 = x22*(x42 + x60 - V{0.972222222222222}*cell[4]) - x23*(cell[4] + V{0.0277777777777778}) + cell[4];
auto x5 = x22*(x60 + x61 - V{0.972222222222222}*cell[5]) - x23*(cell[5] + V{0.0277777777777778}) + cell[5];
auto x6 = x22*(x48 + x62 - V{0.972222222222222}*cell[6]) - x23*(cell[6] + V{0.0277777777777778}) + cell[6];
auto x7 = x22*(x47 + x62 - V{0.972222222222222}*cell[7]) - x23*(cell[7] + V{0.0277777777777778}) + cell[7];
auto x8 = x22*(x50 + x63 - V{0.972222222222222}*cell[8]) - x23*(cell[8] + V{0.0277777777777778}) + cell[8];
auto x9 = x22*(x49 + x63 - V{0.972222222222222}*cell[9]) - x23*(cell[9] + V{0.0277777777777778}) + cell[9];
auto x10 = x22*(x21 + x41 - V{0.944444444444444}*cell[10]) - x23*(cell[10] + V{0.0555555555555556}) + cell[10];
auto x11 = x22*(x32 + x64 - V{0.944444444444444}*cell[11]) - x23*(cell[11] + V{0.0555555555555556}) + cell[11];
auto x12 = x22*(x31 + x64 - V{0.944444444444444}*cell[12]) - x23*(cell[12] + V{0.0555555555555556}) + cell[12];
auto x13 = x22*(x55 + x65 - V{0.972222222222222}*cell[13]) - x23*(cell[13] + V{0.0277777777777778}) + cell[13];
auto x14 = x22*(x54 + x65 - V{0.972222222222222}*cell[14]) - x23*(cell[14] + V{0.0277777777777778}) + cell[14];
auto x15 = x22*(x57 + x66 - V{0.972222222222222}*cell[15]) - x23*(cell[15] + V{0.0277777777777778}) + cell[15];
auto x16 = x22*(x56 + x66 - V{0.972222222222222}*cell[16]) - x23*(cell[16] + V{0.0277777777777778}) + cell[16];
auto x17 = x22*(x59 + x67 - V{0.972222222222222}*cell[17]) - x23*(cell[17] + V{0.0277777777777778}) + cell[17];
auto x18 = x22*(x58 + x67 - V{0.972222222222222}*cell[18]) - x23*(cell[18] + V{0.0277777777777778}) + cell[18];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { cell[0] + cell[10] + cell[11] + cell[12] + cell[13] + cell[14] + cell[15] + cell[16] + cell[17] + cell[18] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1}, V{0} };
}
 
};
 
template <typename... FIELDS>
struct Poisson::type<descriptors::D3Q27<FIELDS...>,momenta::PoissonTuple,equilibria::ZerothOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x31 = parameters.template get<olb::collision::Poisson::SINK>();
auto x30 = parameters.template get<olb::descriptors::OMEGA>();
auto x27 = V{0.0740740740740741}*cell[2];
auto x28 = V{0.0740740740740741}*cell[0];
auto x29 = V{0.0740740740740741}*cell[3];
auto x32 = V{0.0740740740740741}*cell[4];
auto x33 = V{0.0740740740740741}*cell[5];
auto x34 = V{0.0740740740740741}*cell[6];
auto x35 = V{0.0740740740740741}*cell[7];
auto x36 = V{0.0740740740740741}*cell[8];
auto x37 = V{0.0740740740740741}*cell[9];
auto x38 = V{0.0740740740740741}*cell[10];
auto x39 = V{0.0740740740740741}*cell[11];
auto x40 = V{0.0740740740740741}*cell[12];
auto x41 = V{0.0740740740740741}*cell[13];
auto x42 = V{0.0740740740740741}*cell[14];
auto x43 = V{0.0740740740740741}*cell[15];
auto x44 = V{0.0740740740740741}*cell[16];
auto x45 = V{0.0740740740740741}*cell[17];
auto x46 = V{0.0740740740740741}*cell[18];
auto x47 = V{0.0740740740740741}*cell[19];
auto x48 = V{0.0740740740740741}*cell[20];
auto x49 = V{0.0740740740740741}*cell[21];
auto x50 = V{0.0740740740740741}*cell[22];
auto x51 = V{0.0740740740740741}*cell[23];
auto x52 = V{0.0740740740740741}*cell[24];
auto x53 = V{0.0740740740740741}*cell[25];
auto x54 = V{0.0740740740740741}*cell[26];
auto x55 = x28 + x29 + x32 + x33 + x34 + x35 + x36 + x37 + x38 + x39 + x40 + x41 + x42 + x43 + x44 + x45 + x46 + x47 + x48 + x49 + x50 + x51 + x52 + x53 + x54;
auto x56 = V{0.0740740740740741}*cell[1];
auto x57 = x27 + x28 + x32 + x33 + x34 + x35 + x36 + x37 + x38 + x39 + x40 + x41 + x43 + x44 + x45 + x46 + x47 + x48 + x49 + x50 + x51 + x52 + x53 + x54 + x56;
auto x58 = V{0.0185185185185185}*cell[5];
auto x59 = V{0.0185185185185185}*cell[0];
auto x60 = V{0.0185185185185185}*cell[1];
auto x61 = V{0.0185185185185185}*cell[2];
auto x62 = V{0.0185185185185185}*cell[3];
auto x63 = V{0.0185185185185185}*cell[6];
auto x64 = V{0.0185185185185185}*cell[7];
auto x65 = V{0.0185185185185185}*cell[8];
auto x66 = V{0.0185185185185185}*cell[9];
auto x67 = V{0.0185185185185185}*cell[10];
auto x68 = V{0.0185185185185185}*cell[11];
auto x69 = V{0.0185185185185185}*cell[12];
auto x70 = V{0.0185185185185185}*cell[13];
auto x71 = V{0.0185185185185185}*cell[14];
auto x72 = V{0.0185185185185185}*cell[15];
auto x73 = V{0.0185185185185185}*cell[16];
auto x74 = V{0.0185185185185185}*cell[17];
auto x75 = V{0.0185185185185185}*cell[18];
auto x76 = V{0.0185185185185185}*cell[19];
auto x77 = V{0.0185185185185185}*cell[20];
auto x78 = V{0.0185185185185185}*cell[21];
auto x79 = V{0.0185185185185185}*cell[22];
auto x80 = V{0.0185185185185185}*cell[23];
auto x81 = V{0.0185185185185185}*cell[24];
auto x82 = V{0.0185185185185185}*cell[25];
auto x83 = V{0.0185185185185185}*cell[26];
auto x84 = x59 + x60 + x61 + x62 + x63 + x64 + x65 + x66 + x67 + x68 + x69 + x70 + x71 + x72 + x73 + x74 + x75 + x76 + x77 + x78 + x79 + x80 + x81 + x82 + x83;
auto x85 = V{0.0185185185185185}*cell[4];
auto x86 = x58 + x59 + x60 + x61 + x62 + x65 + x66 + x67 + x68 + x69 + x70 + x71 + x72 + x73 + x74 + x75 + x76 + x77 + x78 + x79 + x80 + x81 + x82 + x83 + x85;
auto x87 = x58 + x59 + x60 + x61 + x62 + x63 + x64 + x67 + x68 + x69 + x70 + x71 + x72 + x73 + x74 + x75 + x76 + x77 + x78 + x79 + x80 + x81 + x82 + x83 + x85;
auto x88 = V{0.00462962962962963}*cell[11];
auto x89 = V{0.00462962962962963}*cell[0];
auto x90 = V{0.00462962962962963}*cell[1];
auto x91 = V{0.00462962962962963}*cell[2];
auto x92 = V{0.00462962962962963}*cell[3];
auto x93 = V{0.00462962962962963}*cell[4];
auto x94 = V{0.00462962962962963}*cell[5];
auto x95 = V{0.00462962962962963}*cell[6];
auto x96 = V{0.00462962962962963}*cell[7];
auto x97 = V{0.00462962962962963}*cell[8];
auto x98 = V{0.00462962962962963}*cell[9];
auto x99 = V{0.00462962962962963}*cell[12];
auto x100 = V{0.00462962962962963}*cell[13];
auto x101 = V{0.00462962962962963}*cell[14];
auto x102 = V{0.00462962962962963}*cell[15];
auto x103 = V{0.00462962962962963}*cell[16];
auto x104 = V{0.00462962962962963}*cell[17];
auto x105 = V{0.00462962962962963}*cell[18];
auto x106 = V{0.00462962962962963}*cell[19];
auto x107 = V{0.00462962962962963}*cell[20];
auto x108 = V{0.00462962962962963}*cell[21];
auto x109 = V{0.00462962962962963}*cell[22];
auto x110 = V{0.00462962962962963}*cell[23];
auto x111 = V{0.00462962962962963}*cell[24];
auto x112 = V{0.00462962962962963}*cell[25];
auto x113 = V{0.00462962962962963}*cell[26];
auto x114 = x100 + x101 + x102 + x103 + x104 + x105 + x106 + x107 + x108 + x109 + x110 + x111 + x112 + x113 + x89 + x90 + x91 + x92 + x93 + x94 + x95 + x96 + x97 + x98 + x99;
auto x115 = V{0.00462962962962963}*cell[10];
auto x116 = x101 + x102 + x103 + x104 + x105 + x106 + x107 + x108 + x109 + x110 + x111 + x112 + x113 + x115 + x88 + x89 + x90 + x91 + x92 + x93 + x94 + x95 + x96 + x97 + x98;
auto x117 = x27 + x28 + x29 + x32 + x33 + x34 + x35 + x36 + x37 + x38 + x39 + x40 + x41 + x42 + x45 + x46 + x47 + x48 + x49 + x50 + x51 + x52 + x53 + x54 + x56;
auto x118 = x58 + x59 + x60 + x61 + x62 + x63 + x64 + x65 + x66 + x67 + x68 + x69 + x70 + x71 + x72 + x73 + x76 + x77 + x78 + x79 + x80 + x81 + x82 + x83 + x85;
auto x119 = x58 + x59 + x60 + x61 + x62 + x63 + x64 + x65 + x66 + x67 + x68 + x69 + x70 + x71 + x72 + x73 + x74 + x75 + x78 + x79 + x80 + x81 + x82 + x83 + x85;
auto x120 = x58 + x59 + x60 + x61 + x62 + x63 + x64 + x65 + x66 + x67 + x68 + x69 + x70 + x71 + x72 + x73 + x74 + x75 + x76 + x77 + x80 + x81 + x82 + x83 + x85;
auto x121 = x100 + x101 + x102 + x103 + x104 + x105 + x106 + x107 + x108 + x109 + x112 + x113 + x115 + x88 + x89 + x90 + x91 + x92 + x93 + x94 + x95 + x96 + x97 + x98 + x99;
auto x122 = x100 + x101 + x102 + x103 + x104 + x105 + x106 + x107 + x108 + x109 + x110 + x111 + x115 + x88 + x89 + x90 + x91 + x92 + x93 + x94 + x95 + x96 + x97 + x98 + x99;
auto x0 = x30*(-V{0.703703703703704}*cell[0] + V{0.296296296296296}*cell[10] + V{0.296296296296296}*cell[11] + V{0.296296296296296}*cell[12] + V{0.296296296296296}*cell[13] + V{0.296296296296296}*cell[14] + V{0.296296296296296}*cell[15] + V{0.296296296296296}*cell[16] + V{0.296296296296296}*cell[17] + V{0.296296296296296}*cell[18] + V{0.296296296296296}*cell[19] + V{0.296296296296296}*cell[1] + V{0.296296296296296}*cell[20] + V{0.296296296296296}*cell[21] + V{0.296296296296296}*cell[22] + V{0.296296296296296}*cell[23] + V{0.296296296296296}*cell[24] + V{0.296296296296296}*cell[25] + V{0.296296296296296}*cell[26] + V{0.296296296296296}*cell[2] + V{0.296296296296296}*cell[3] + V{0.296296296296296}*cell[4] + V{0.296296296296296}*cell[5] + V{0.296296296296296}*cell[6] + V{0.296296296296296}*cell[7] + V{0.296296296296296}*cell[8] + V{0.296296296296296}*cell[9]) - x31*(cell[0] + V{0.296296296296296}) + cell[0];
auto x1 = x30*(x27 + x55 - V{0.925925925925926}*cell[1]) - x31*(cell[1] + V{0.0740740740740741}) + cell[1];
auto x2 = x30*(x55 + x56 - V{0.925925925925926}*cell[2]) - x31*(cell[2] + V{0.0740740740740741}) + cell[2];
auto x3 = x30*(x42 + x57 - V{0.925925925925926}*cell[3]) - x31*(cell[3] + V{0.0740740740740741}) + cell[3];
auto x4 = x30*(x58 + x84 - V{0.981481481481482}*cell[4]) - x31*(cell[4] + V{0.0185185185185185}) + cell[4];
auto x5 = x30*(x84 + x85 - V{0.981481481481482}*cell[5]) - x31*(cell[5] + V{0.0185185185185185}) + cell[5];
auto x6 = x30*(x64 + x86 - V{0.981481481481482}*cell[6]) - x31*(cell[6] + V{0.0185185185185185}) + cell[6];
auto x7 = x30*(x63 + x86 - V{0.981481481481482}*cell[7]) - x31*(cell[7] + V{0.0185185185185185}) + cell[7];
auto x8 = x30*(x66 + x87 - V{0.981481481481482}*cell[8]) - x31*(cell[8] + V{0.0185185185185185}) + cell[8];
auto x9 = x30*(x65 + x87 - V{0.981481481481482}*cell[9]) - x31*(cell[9] + V{0.0185185185185185}) + cell[9];
auto x10 = x30*(x114 + x88 - V{0.99537037037037}*cell[10]) - x31*(cell[10] + V{0.00462962962962963}) + cell[10];
auto x11 = x30*(x114 + x115 - V{0.99537037037037}*cell[11]) - x31*(cell[11] + V{0.00462962962962963}) + cell[11];
auto x12 = x30*(x100 + x116 - V{0.99537037037037}*cell[12]) - x31*(cell[12] + V{0.00462962962962963}) + cell[12];
auto x13 = x30*(x116 + x99 - V{0.99537037037037}*cell[13]) - x31*(cell[13] + V{0.00462962962962963}) + cell[13];
auto x14 = x30*(x29 + x57 - V{0.925925925925926}*cell[14]) - x31*(cell[14] + V{0.0740740740740741}) + cell[14];
auto x15 = x30*(x117 + x44 - V{0.925925925925926}*cell[15]) - x31*(cell[15] + V{0.0740740740740741}) + cell[15];
auto x16 = x30*(x117 + x43 - V{0.925925925925926}*cell[16]) - x31*(cell[16] + V{0.0740740740740741}) + cell[16];
auto x17 = x30*(x118 + x75 - V{0.981481481481482}*cell[17]) - x31*(cell[17] + V{0.0185185185185185}) + cell[17];
auto x18 = x30*(x118 + x74 - V{0.981481481481482}*cell[18]) - x31*(cell[18] + V{0.0185185185185185}) + cell[18];
auto x19 = x30*(x119 + x77 - V{0.981481481481482}*cell[19]) - x31*(cell[19] + V{0.0185185185185185}) + cell[19];
auto x20 = x30*(x119 + x76 - V{0.981481481481482}*cell[20]) - x31*(cell[20] + V{0.0185185185185185}) + cell[20];
auto x21 = x30*(x120 + x79 - V{0.981481481481482}*cell[21]) - x31*(cell[21] + V{0.0185185185185185}) + cell[21];
auto x22 = x30*(x120 + x78 - V{0.981481481481482}*cell[22]) - x31*(cell[22] + V{0.0185185185185185}) + cell[22];
auto x23 = x30*(x111 + x121 - V{0.99537037037037}*cell[23]) - x31*(cell[23] + V{0.00462962962962963}) + cell[23];
auto x24 = x30*(x110 + x121 - V{0.99537037037037}*cell[24]) - x31*(cell[24] + V{0.00462962962962963}) + cell[24];
auto x25 = x30*(x113 + x122 - V{0.99537037037037}*cell[25]) - x31*(cell[25] + V{0.00462962962962963}) + cell[25];
auto x26 = x30*(x112 + x122 - V{0.99537037037037}*cell[26]) - x31*(cell[26] + V{0.00462962962962963}) + cell[26];
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
cell[19] = x19;
cell[20] = x20;
cell[21] = x21;
cell[22] = x22;
cell[23] = x23;
cell[24] = x24;
cell[25] = x25;
cell[26] = x26;
return { cell[0] + cell[10] + cell[11] + cell[12] + cell[13] + cell[14] + cell[15] + cell[16] + cell[17] + cell[18] + cell[19] + cell[1] + cell[20] + cell[21] + cell[22] + cell[23] + cell[24] + cell[25] + cell[26] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1}, V{0} };
}
 
};
 
 
template <typename... FIELDS>
struct P1::type<descriptors::D3Q7<FIELDS...>,momenta::P1Tuple,equilibria::P1> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x7 = parameters.template get<olb::collision::P1::SCATTERING>();
auto x8 = parameters.template get<olb::collision::P1::ABSORPTION>();
auto x9 = V{0.166666666666667}*cell[0];
auto x10 = x9 + V{0.166666666666667}*cell[3] + V{0.166666666666667}*cell[6];
auto x11 = V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[5];
auto x12 = x10 + x11;
auto x13 = V{1}*x7;
auto x14 = V{1}*x8;
auto x15 = V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[4];
auto x16 = x10 + x15;
auto x17 = x11 + x15 + x9;
cell[0] = cell[0];
cell[1] = x13*(x12 - V{0.666666666666667}*cell[1]) - x14*(cell[1] + V{0.166666666666667}) + cell[1];
cell[2] = x13*(x16 - V{0.666666666666667}*cell[2]) - x14*(cell[2] + V{0.166666666666667}) + cell[2];
cell[3] = x13*(x17 - V{0.666666666666667}*cell[3]) - x14*(cell[3] + V{0.166666666666667}) + cell[3];
cell[4] = x13*(x12 - V{0.666666666666667}*cell[4]) - x14*(cell[4] + V{0.166666666666667}) + cell[4];
cell[5] = x13*(x16 - V{0.666666666666667}*cell[5]) - x14*(cell[5] + V{0.166666666666667}) + cell[5];
cell[6] = x13*(x17 - V{0.666666666666667}*cell[6]) - x14*(cell[6] + V{0.166666666666667}) + cell[6];
return { cell[0] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + V{1}, V{0} };
}
 
};
 
template <typename... FIELDS>
struct P1::type<descriptors::D3Q15<FIELDS...>,momenta::P1Tuple,equilibria::P1> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x15 = parameters.template get<olb::collision::P1::SCATTERING>();
auto x16 = parameters.template get<olb::collision::P1::ABSORPTION>();
auto x17 = V{0.133333333333333}*cell[7];
auto x18 = V{0.0666666666666667}*cell[0];
auto x19 = V{0.0666666666666667}*cell[3];
auto x20 = V{0.0666666666666667}*cell[10];
auto x21 = V{0.133333333333333}*cell[4];
auto x22 = V{0.133333333333333}*cell[5];
auto x23 = x18 + x19 + x20 + x21 + x22;
auto x24 = V{0.0666666666666667}*cell[2];
auto x25 = V{0.0666666666666667}*cell[9];
auto x26 = V{0.133333333333333}*cell[6];
auto x27 = x24 + x25 + x26;
auto x28 = V{1}*x15;
auto x29 = V{1}*x16;
auto x30 = V{0.133333333333333}*cell[13];
auto x31 = V{0.133333333333333}*cell[14];
auto x32 = x30 + x31;
auto x33 = V{0.0666666666666667}*cell[1] + V{0.0666666666666667}*cell[8];
auto x34 = x18 + V{0.133333333333333}*cell[12];
auto x35 = x33 + x34;
auto x36 = V{0.15}*cell[11];
auto x37 = V{0.075}*cell[0];
auto x38 = V{0.15}*cell[1];
auto x39 = V{0.15}*cell[2];
auto x40 = x37 + x38 + x39;
auto x41 = V{0.15}*cell[5];
auto x42 = V{0.15}*cell[6];
auto x43 = x41 + x42;
auto x44 = V{0.15}*cell[3];
auto x45 = V{0.15}*cell[14];
auto x46 = x44 + x45;
auto x47 = V{1.732051}*x15;
auto x48 = V{1.732051}*x16;
auto x49 = V{0.15}*cell[12];
auto x50 = V{0.15}*cell[4];
auto x51 = V{0.15}*cell[7];
auto x52 = x50 + x51;
auto x53 = V{0.15}*cell[10];
auto x54 = V{0.15}*cell[13];
auto x55 = x53 + x54;
auto x56 = x37 + V{0.15}*cell[9];
auto x57 = x38 + x56;
auto x58 = x44 + x49;
auto x59 = x36 + x53;
auto x60 = V{0.133333333333333}*cell[11];
auto x61 = x19 + x20 + x60;
auto x62 = x24 + x25;
auto x63 = V{0.15}*cell[8];
auto x64 = x56 + x63;
auto x65 = x37 + x39 + x63;
cell[0] = cell[0];
cell[1] = x28*(x17 + x23 + x27 - V{0.866666666666667}*cell[1]) - x29*(cell[1] + V{0.0666666666666667}) + cell[1];
cell[2] = x28*(x23 + x32 + x33 - V{0.866666666666667}*cell[2]) - x29*(cell[2] + V{0.0666666666666667}) + cell[2];
cell[3] = x28*(x21 + x27 + x31 + x35 - V{0.866666666666667}*cell[3]) - x29*(cell[3] + V{0.0666666666666667}) + cell[3];
cell[4] = x47*(-x36 + x40 + x43 + x46 - V{0.7}*cell[4]) - x48*(cell[4] + V{0.075}) + cell[4];
cell[5] = x47*(x40 - x49 + x52 + x55 - V{0.7}*cell[5]) - x48*(cell[5] + V{0.075}) + cell[5];
cell[6] = x47*(x52 - x54 + x57 + x58 - V{0.7}*cell[6]) - x48*(cell[6] + V{0.075}) + cell[6];
cell[7] = x47*(x43 - x45 + x57 + x59 - V{0.7}*cell[7]) - x48*(cell[7] + V{0.075}) + cell[7];
cell[8] = x28*(x32 + x34 + x61 + x62 - V{0.866666666666667}*cell[8]) - x29*(cell[8] + V{0.0666666666666667}) + cell[8];
cell[9] = x28*(x17 + x26 + x35 + x61 - V{0.866666666666667}*cell[9]) - x29*(cell[9] + V{0.0666666666666667}) + cell[9];
cell[10] = x28*(x17 + x18 + x22 + x30 + x33 + x60 + x62 - V{0.866666666666667}*cell[10]) - x29*(cell[10] + V{0.0666666666666667}) + cell[10];
cell[11] = x47*(x49 - x50 + x51 + x55 + x64 - V{0.7}*cell[11]) - x48*(cell[11] + V{0.075}) + cell[11];
cell[12] = x47*(x36 - x41 + x42 + x46 + x64 - V{0.7}*cell[12]) - x48*(cell[12] + V{0.075}) + cell[12];
cell[13] = x47*(x41 - x42 + x45 + x59 + x65 - V{0.7}*cell[13]) - x48*(cell[13] + V{0.075}) + cell[13];
cell[14] = x47*(x50 - x51 + x54 + x58 + x65 - V{0.7}*cell[14]) - x48*(cell[14] + V{0.075}) + cell[14];
return { cell[0] + cell[10] + cell[11] + cell[12] + cell[13] + cell[14] + cell[1] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1}, V{0} };
}
 
};
 
template <typename... FIELDS>
struct P1::type<descriptors::D3Q27<FIELDS...>,momenta::P1Tuple,equilibria::P1> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x28 = parameters.template get<olb::collision::P1::ABSORPTION>();
auto x27 = parameters.template get<olb::collision::P1::SCATTERING>();
auto x29 = V{0.0952380952380952}*cell[7];
auto x30 = V{0.0476190476190476}*cell[0];
auto x31 = V{0.0476190476190476}*cell[3];
auto x32 = V{0.0476190476190476}*cell[16];
auto x33 = V{0.0952380952380952}*cell[10];
auto x34 = V{0.0952380952380952}*cell[11];
auto x35 = x30 + x31 + x32 + x33 + x34 + V{0.0952380952380952}*cell[4];
auto x36 = V{0.0476190476190476}*cell[2];
auto x37 = V{0.0476190476190476}*cell[15];
auto x38 = V{0.0952380952380952}*cell[12];
auto x39 = x36 + x37 + x38 + V{0.0952380952380952}*cell[6];
auto x40 = V{0.0952380952380952}*cell[13];
auto x41 = x40 + V{0.0952380952380952}*cell[5];
auto x42 = V{0.0476190476190476}*cell[21] + V{0.0476190476190476}*cell[22] + V{0.0476190476190476}*cell[8] + V{0.0476190476190476}*cell[9];
auto x43 = V{1}*x27;
auto x44 = V{1}*x28;
auto x45 = V{0.0952380952380952}*cell[9];
auto x46 = V{0.0952380952380952}*cell[25];
auto x47 = V{0.0952380952380952}*cell[26];
auto x48 = x46 + x47 + V{0.0952380952380952}*cell[18];
auto x49 = V{0.0476190476190476}*cell[1];
auto x50 = V{0.0476190476190476}*cell[14];
auto x51 = x49 + x50 + V{0.0952380952380952}*cell[8];
auto x52 = V{0.0476190476190476}*cell[19] + V{0.0476190476190476}*cell[20] + V{0.0476190476190476}*cell[6] + V{0.0476190476190476}*cell[7];
auto x53 = V{0.0952380952380952}*cell[22];
auto x54 = V{0.0952380952380952}*cell[24];
auto x55 = x30 + x54 + V{0.0952380952380952}*cell[20];
auto x56 = V{0.0476190476190476}*cell[17] + V{0.0476190476190476}*cell[18] + V{0.0476190476190476}*cell[4] + V{0.0476190476190476}*cell[5];
auto x57 = V{0.0380952380952381}*cell[17];
auto x58 = V{0.0380952380952381}*cell[0];
auto x59 = V{0.0380952380952381}*cell[13];
auto x60 = V{0.0380952380952381}*cell[26];
auto x61 = V{0.0761904761904762}*cell[9];
auto x62 = x58 + x59 + x60 + x61;
auto x63 = V{0.0380952380952381}*cell[12];
auto x64 = V{0.0380952380952381}*cell[25];
auto x65 = V{0.0761904761904762}*cell[8];
auto x66 = x63 + x64 + x65;
auto x67 = V{0.0380952380952381}*cell[3];
auto x68 = V{0.0380952380952381}*cell[16];
auto x69 = V{0.0761904761904762}*cell[1];
auto x70 = V{0.0761904761904762}*cell[6];
auto x71 = V{0.0761904761904762}*cell[7];
auto x72 = x67 + x68 + x69 + x70 + x71;
auto x73 = V{0.0380952380952381}*cell[24];
auto x74 = -x73 + V{0.114285714285714}*cell[11];
auto x75 = V{0.0761904761904762}*cell[2];
auto x76 = V{0.0380952380952381}*cell[23];
auto x77 = -x76 + V{0.114285714285714}*cell[10];
auto x78 = x75 + x77;
auto x79 = V{0.0380952380952381}*cell[5];
auto x80 = V{0.0380952380952381}*cell[18];
auto x81 = x79 + x80;
auto x82 = V{1.414214}*x27;
auto x83 = V{1.414214}*x28;
auto x84 = V{0.0761904761904762}*cell[15];
auto x85 = V{0.0761904761904762}*cell[21];
auto x86 = V{0.0761904761904762}*cell[22];
auto x87 = x84 + x85 + x86;
auto x88 = V{0.114285714285714}*cell[12];
auto x89 = -x64;
auto x90 = V{0.0380952380952381}*cell[11];
auto x91 = x58 + x73 + x90;
auto x92 = x88 + x89 + x91;
auto x93 = V{0.114285714285714}*cell[13];
auto x94 = -x60;
auto x95 = V{0.0380952380952381}*cell[10];
auto x96 = x76 + x95;
auto x97 = x93 + x94 + x96;
auto x98 = V{0.0380952380952381}*cell[4];
auto x99 = x57 + x98;
auto x100 = V{0.0380952380952381}*cell[19];
auto x101 = V{0.0761904761904762}*cell[3];
auto x102 = V{0.0761904761904762}*cell[4];
auto x103 = x101 + x102;
auto x104 = V{0.0380952380952381}*cell[2];
auto x105 = V{0.0380952380952381}*cell[7];
auto x106 = V{0.0380952380952381}*cell[15];
auto x107 = V{0.0380952380952381}*cell[20];
auto x108 = x104 + x105 + x106 + x107;
auto x109 = V{0.0761904761904762}*cell[5];
auto x110 = x59 + x60;
auto x111 = x109 + x110;
auto x112 = V{0.0761904761904762}*cell[16];
auto x113 = x112 + x85;
auto x114 = x63 + x64;
auto x115 = x114 + x58;
auto x116 = x102 + x74;
auto x117 = V{0.0380952380952381}*cell[6];
auto x118 = x100 + x104 + x106 + x117;
auto x119 = V{0.0380952380952381}*cell[21];
auto x120 = V{0.0380952380952381}*cell[1];
auto x121 = V{0.0380952380952381}*cell[14];
auto x122 = V{0.0761904761904762}*cell[18];
auto x123 = x120 + x121 + x122;
auto x124 = V{0.0761904761904762}*cell[20];
auto x125 = -x59 + V{0.114285714285714}*cell[26];
auto x126 = x124 + x125 + x91;
auto x127 = V{0.0380952380952381}*cell[9];
auto x128 = V{0.0380952380952381}*cell[22];
auto x129 = x114 + x127 + x128;
auto x130 = V{0.0761904761904762}*cell[19];
auto x131 = x110 + x130;
auto x132 = x112 + x71;
auto x133 = V{0.0380952380952381}*cell[8];
auto x134 = x58 + x96;
auto x135 = x119 + x133 + x134;
auto x136 = -x63 + V{0.114285714285714}*cell[25];
auto x137 = x136 + x75;
auto x138 = V{0.0642857142857143}*cell[23];
auto x139 = V{0.0321428571428571}*cell[0];
auto x140 = V{0.0321428571428571}*cell[9];
auto x141 = V{0.0321428571428571}*cell[22];
auto x142 = V{0.0642857142857143}*cell[1];
auto x143 = V{0.0642857142857143}*cell[11];
auto x144 = V{0.0642857142857143}*cell[12];
auto x145 = x139 + x140 + x141 + x142 + x143 + x144;
auto x146 = V{0.0321428571428571}*cell[5];
auto x147 = V{0.0321428571428571}*cell[18];
auto x148 = V{0.0642857142857143}*cell[3];
auto x149 = V{0.0642857142857143}*cell[26];
auto x150 = x146 + x147 + x148 + x149;
auto x151 = V{0.0321428571428571}*cell[7];
auto x152 = V{0.0321428571428571}*cell[20];
auto x153 = V{0.0642857142857143}*cell[2];
auto x154 = x151 + x152 + x153;
auto x155 = V{0.0321428571428571}*cell[17];
auto x156 = -x155 + V{0.0964285714285714}*cell[4];
auto x157 = V{0.0321428571428571}*cell[19];
auto x158 = -x157 + V{0.0964285714285714}*cell[6];
auto x159 = V{0.0321428571428571}*cell[21];
auto x160 = -x159 + V{0.0964285714285714}*cell[8];
auto x161 = V{1.732051}*x27;
auto x162 = V{1.732051}*x28;
auto x163 = V{0.0642857142857143}*cell[24];
auto x164 = V{0.0321428571428571}*cell[6];
auto x165 = V{0.0642857142857143}*cell[16];
auto x166 = -x152 + x157 + x164 + x165 + V{0.0964285714285714}*cell[7];
auto x167 = V{0.0642857142857143}*cell[10];
auto x168 = V{0.0642857142857143}*cell[13];
auto x169 = V{0.0321428571428571}*cell[8];
auto x170 = x139 + x159 + x169;
auto x171 = x142 + x167 + x168 + x170;
auto x172 = V{0.0642857142857143}*cell[25];
auto x173 = x146 + x147 + x172;
auto x174 = -x141 + V{0.0964285714285714}*cell[9];
auto x175 = V{0.0642857142857143}*cell[15];
auto x176 = -x140 + x175 + V{0.0964285714285714}*cell[22];
auto x177 = x151 + x152 + x163;
auto x178 = V{0.0321428571428571}*cell[4];
auto x179 = x155 + x178;
auto x180 = x148 + x179;
auto x181 = -x147 + V{0.0964285714285714}*cell[5];
auto x182 = x138 + x179;
auto x183 = -x169 + x175 + V{0.0964285714285714}*cell[21];
auto x184 = V{0.0952380952380952}*cell[23];
auto x185 = x184 + x31 + x32 + V{0.0952380952380952}*cell[17];
auto x186 = x36 + x37 + V{0.0952380952380952}*cell[19];
auto x187 = x30 + x49 + x50 + V{0.0952380952380952}*cell[21];
auto x188 = -x95 + V{0.114285714285714}*cell[23];
auto x189 = V{0.0761904761904762}*cell[14];
auto x190 = x189 + x67 + x68;
auto x191 = -x90 + V{0.114285714285714}*cell[24];
auto x192 = x124 + x191;
auto x193 = V{0.0761904761904762}*cell[17];
auto x194 = x188 + x193;
auto x195 = x122 + x189;
auto x196 = x101 + x193;
auto x197 = x120 + x121 + x84;
auto x198 = V{0.0642857142857143}*cell[14];
auto x199 = -x178 + x198 + V{0.0964285714285714}*cell[17];
auto x200 = -x164 + x165 + V{0.0964285714285714}*cell[19];
auto x201 = x139 + x140 + x141;
auto x202 = -x151 + x157 + x164 + V{0.0964285714285714}*cell[20];
auto x203 = -x146 + x198 + V{0.0964285714285714}*cell[18];
cell[0] = cell[0];
cell[1] = x43*(x29 + x35 + x39 + x41 + x42 - V{0.904761904761905}*cell[1]) - x44*(cell[1] + V{0.0476190476190476}) + cell[1];
cell[2] = x43*(x35 + x45 + x48 + x51 + x52 - V{0.904761904761905}*cell[2]) - x44*(cell[2] + V{0.0476190476190476}) + cell[2];
cell[3] = x43*(x33 + x39 + x47 + x51 + x53 + x55 + x56 - V{0.904761904761905}*cell[3]) - x44*(cell[3] + V{0.0476190476190476}) + cell[3];
cell[4] = x82*(-x57 + x62 + x66 + x72 + x74 + x78 + x81 - V{0.885714285714286}*cell[4]) - x83*(cell[4] + V{0.0380952380952381}) + cell[4];
cell[5] = x82*(x72 - x80 + x87 + x92 + x97 + x99 - V{0.885714285714286}*cell[5]) - x83*(cell[5] + V{0.0380952380952381}) + cell[5];
cell[6] = x82*(-x100 + x103 + x108 + x111 + x65 + x69 + x77 + x86 + x92 - V{0.885714285714286}*cell[6]) - x83*(cell[6] + V{0.0380952380952381}) + cell[6];
cell[7] = x82*(-x107 + x109 + x113 + x115 + x116 + x118 + x61 + x69 + x97 - V{0.885714285714286}*cell[7]) - x83*(cell[7] + V{0.0380952380952381}) + cell[7];
cell[8] = x82*(x103 - x119 + x123 + x126 + x129 + x70 + x78 - V{0.885714285714286}*cell[8]) - x83*(cell[8] + V{0.0380952380952381}) + cell[8];
cell[9] = x82*(x116 + x123 - x128 + x131 + x132 + x135 + x137 - V{0.885714285714286}*cell[9]) - x83*(cell[9] + V{0.0380952380952381}) + cell[9];
cell[10] = x161*(-x138 + x145 + x150 + x154 + x156 + x158 + x160 - V{0.871428571428571}*cell[10]) - x162*(cell[10] + V{0.0321428571428571}) + cell[10];
cell[11] = x161*(x153 + x156 - x163 + x166 + x171 + x173 + x174 - V{0.871428571428571}*cell[11]) - x162*(cell[11] + V{0.0321428571428571}) + cell[11];
cell[12] = x161*(x158 + x171 - x172 + x176 + x177 + x180 + x181 - V{0.871428571428571}*cell[12]) - x162*(cell[12] + V{0.0321428571428571}) + cell[12];
cell[13] = x161*(x145 - x149 + x166 + x181 + x182 + x183 - V{0.871428571428571}*cell[13]) - x162*(cell[13] + V{0.0321428571428571}) + cell[13];
cell[14] = x43*(x185 + x186 + x42 + x48 + x55 - V{0.904761904761905}*cell[14]) - x44*(cell[14] + V{0.0476190476190476}) + cell[14];
cell[15] = x43*(x185 + x187 + x38 + x41 + x52 + x53 + x54 - V{0.904761904761905}*cell[15]) - x44*(cell[15] + V{0.0476190476190476}) + cell[15];
cell[16] = x43*(x184 + x186 + x187 + x29 + x34 + x40 + x45 + x46 + x56 - V{0.904761904761905}*cell[16]) - x44*(cell[16] + V{0.0476190476190476}) + cell[16];
cell[17] = x82*(x115 + x131 + x188 + x190 + x192 + x81 + x87 - x98 - V{0.885714285714286}*cell[17]) - x83*(cell[17] + V{0.0380952380952381}) + cell[17];
cell[18] = x82*(x126 + x130 + x137 + x190 + x61 + x65 - x79 + x96 + x99 - V{0.885714285714286}*cell[18]) - x83*(cell[18] + V{0.0380952380952381}) + cell[18];
cell[19] = x82*(x108 + x113 - x117 + x136 + x194 + x195 + x62 + x73 + x90 - V{0.885714285714286}*cell[19]) - x83*(cell[19] + V{0.0380952380952381}) + cell[19];
cell[20] = x82*(-x105 + x118 + x125 + x134 + x191 + x195 + x196 + x66 + x86 - V{0.885714285714286}*cell[20]) - x83*(cell[20] + V{0.0380952380952381}) + cell[20];
cell[21] = x82*(x109 + x129 + x130 + x132 - x133 + x194 + x197 + x91 + x93 + x94 - V{0.885714285714286}*cell[21]) - x83*(cell[21] + V{0.0380952380952381}) + cell[21];
cell[22] = x82*(x111 - x127 + x135 + x192 + x196 + x197 + x70 + x88 + x89 - V{0.885714285714286}*cell[22]) - x83*(cell[22] + V{0.0380952380952381}) + cell[22];
cell[23] = x161*(-x167 + x168 + x173 + x177 + x183 + x199 + x200 + x201 - V{0.871428571428571}*cell[23]) - x162*(cell[23] + V{0.0321428571428571}) + cell[23];
cell[24] = x161*(x138 - x143 + x144 + x150 + x170 + x176 + x199 + x202 - V{0.871428571428571}*cell[24]) - x162*(cell[24] + V{0.0321428571428571}) + cell[24];
cell[25] = x161*(x143 - x144 + x149 + x154 + x170 + x174 + x182 + x200 + x203 - V{0.871428571428571}*cell[25]) - x162*(cell[25] + V{0.0321428571428571}) + cell[25];
cell[26] = x161*(x153 + x160 + x163 + x167 - x168 + x172 + x180 + x201 + x202 + x203 - V{0.871428571428571}*cell[26]) - x162*(cell[26] + V{0.0321428571428571}) + cell[26];
return { cell[0] + cell[10] + cell[11] + cell[12] + cell[13] + cell[14] + cell[15] + cell[16] + cell[17] + cell[18] + cell[19] + cell[1] + cell[20] + cell[21] + cell[22] + cell[23] + cell[24] + cell[25] + cell[26] + cell[2] + cell[3] + cell[4] + cell[5] + cell[6] + cell[7] + cell[8] + cell[9] + V{1}, V{0} };
}
 
};
 
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<0,-1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x23 = x22 + V{-1};
auto x24 = x19 + V{-1};
auto x25 = cell[0] + cell[11] + cell[12] + cell[17] + cell[18] + V{2}*cell[1] + cell[2] + cell[3] + V{2}*cell[4] + V{2}*cell[5] + V{2}*cell[6] + V{2}*cell[7] + cell[8] + cell[9] + V{1};
auto x26 = -x25/x24;
auto x27 = x19*x19;
auto x28 = V{1.5}*x27;
auto x29 = x20*x20;
auto x30 = V{1.5}*x29;
auto x31 = x21*x21;
auto x32 = V{1.5}*x31;
auto x33 = x30 + x32 + V{-1};
auto x34 = x28 + x33;
auto x35 = V{0.0555555555555556}*x22;
auto x36 = V{3}*x19;
auto x37 = V{3}*x20;
auto x38 = x28 + V{-1};
auto x39 = V{3}*x21;
auto x40 = V{0.0277777777777778}*x22;
auto x41 = x19 + x20;
auto x42 = x41*x41;
auto x43 = x34 + x36;
auto x44 = -x37;
auto x45 = x19 - x20;
auto x46 = -x45;
auto x47 = x19 + x21;
auto x48 = x47*x47;
auto x49 = -x39;
auto x50 = -x21;
auto x51 = x19 + x50;
auto x52 = -x51;
auto x53 = x20 + x21;
auto x54 = x53*x53;
auto x55 = x34 + x37;
auto x56 = x20 + x50;
auto x57 = -x56;
auto x58 = -x30;
auto x59 = V{1} - x32;
auto x60 = x58 + x59;
auto x61 = x36 + x60;
auto x62 = -x28;
auto x63 = x37 + x62;
auto x64 = x39 + x62;
auto x65 = -x36;
auto x66 = x34 + x39;
cell[0] = -V{0.333333333333333}*x22*(x26*x34 + V{1}) - x23*cell[0];
cell[1] = -x23*cell[1] - x35*(-x26*(V{3}*x27 - x33 - x36) + V{1});
cell[2] = -x23*cell[2] - x35*(-x26*(V{3}*x29 - x32 - x37 - x38) + V{1});
cell[3] = -x23*cell[3] - x35*(-x26*(-x30 + V{3}*x31 - x38 - x39) + V{1});
cell[4] = -x23*cell[4] - x40*(-x26*(-x37 + V{4.5}*x42 - x43) + V{1});
cell[5] = -x23*cell[5] - x40*(x26*(x43 + x44 - V{4.5}*x46*x46) + V{1});
cell[6] = -x23*cell[6] - x40*(-x26*(-x39 - x43 + V{4.5}*x48) + V{1});
cell[7] = -x23*cell[7] - x40*(x26*(x43 + x49 - V{4.5}*x52*x52) + V{1});
cell[8] = -x23*cell[8] - x40*(-x26*(-x39 + V{4.5}*x54 - x55) + V{1});
cell[9] = -x23*cell[9] - x40*(x26*(x49 + x55 - V{4.5}*x57*x57) + V{1});
cell[10] = -x23*cell[10] - x35*(-x26*(V{3}*x27 + x61) + V{1});
cell[11] = -x23*cell[11] - x35*(-x26*(V{3}*x29 + x59 + x63) + V{1});
cell[12] = -x23*cell[12] - x35*(-x26*(V{3}*x31 + x58 + x64 + V{1}) + V{1});
cell[13] = -x23*cell[13] - x40*(-x26*(V{4.5}*x42 + x61 + x63) + V{1});
cell[14] = -x23*cell[14] - x40*(x26*(x55 + x65 - V{4.5}*x45*x45) + V{1});
cell[15] = -x23*cell[15] - x40*(-x26*(V{4.5}*x48 + x61 + x64) + V{1});
cell[16] = -x23*cell[16] - x40*(x26*(x65 + x66 - V{4.5}*x51*x51) + V{1});
cell[17] = -x23*cell[17] - x40*(-x26*(x39 + V{4.5}*x54 + x60 + x63) + V{1});
cell[18] = -x23*cell[18] - x40*(x26*(x44 + x66 - V{4.5}*x56*x56) + V{1});
return { -V{1}*x25/x24, x27 + x29 + x31 };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<0,1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x23 = x22 + V{-1};
auto x24 = (cell[0] + V{2}*cell[10] + cell[11] + cell[12] + V{2}*cell[13] + V{2}*cell[14] + V{2}*cell[15] + V{2}*cell[16] + cell[17] + cell[18] + cell[2] + cell[3] + cell[8] + cell[9] + V{1})/(x19 + V{1});
auto x25 = x19*x19;
auto x26 = V{1.5}*x25;
auto x27 = x20*x20;
auto x28 = V{1.5}*x27;
auto x29 = x21*x21;
auto x30 = V{1.5}*x29;
auto x31 = x28 + x30 + V{-1};
auto x32 = x26 + x31;
auto x33 = V{0.0555555555555556}*x22;
auto x34 = V{3}*x19;
auto x35 = V{3}*x20;
auto x36 = x26 + V{-1};
auto x37 = V{3}*x21;
auto x38 = V{0.0277777777777778}*x22;
auto x39 = x19 + x20;
auto x40 = x39*x39;
auto x41 = x32 + x34;
auto x42 = -x35;
auto x43 = x19 - x20;
auto x44 = -x43;
auto x45 = x19 + x21;
auto x46 = x45*x45;
auto x47 = -x37;
auto x48 = -x21;
auto x49 = x19 + x48;
auto x50 = -x49;
auto x51 = x20 + x21;
auto x52 = x51*x51;
auto x53 = x32 + x35;
auto x54 = x20 + x48;
auto x55 = -x54;
auto x56 = -x28;
auto x57 = V{1} - x30;
auto x58 = x56 + x57;
auto x59 = x34 + x58;
auto x60 = -x26;
auto x61 = x35 + x60;
auto x62 = x37 + x60;
auto x63 = -x34;
auto x64 = x32 + x37;
cell[0] = -V{0.333333333333333}*x22*(x24*x32 + V{1}) - x23*cell[0];
cell[1] = -x23*cell[1] - x33*(-x24*(V{3}*x25 - x31 - x34) + V{1});
cell[2] = -x23*cell[2] - x33*(-x24*(V{3}*x27 - x30 - x35 - x36) + V{1});
cell[3] = -x23*cell[3] - x33*(-x24*(-x28 + V{3}*x29 - x36 - x37) + V{1});
cell[4] = -x23*cell[4] - x38*(-x24*(-x35 + V{4.5}*x40 - x41) + V{1});
cell[5] = -x23*cell[5] - x38*(x24*(x41 + x42 - V{4.5}*x44*x44) + V{1});
cell[6] = -x23*cell[6] - x38*(-x24*(-x37 - x41 + V{4.5}*x46) + V{1});
cell[7] = -x23*cell[7] - x38*(x24*(x41 + x47 - V{4.5}*x50*x50) + V{1});
cell[8] = -x23*cell[8] - x38*(-x24*(-x37 + V{4.5}*x52 - x53) + V{1});
cell[9] = -x23*cell[9] - x38*(x24*(x47 + x53 - V{4.5}*x55*x55) + V{1});
cell[10] = -x23*cell[10] - x33*(-x24*(V{3}*x25 + x59) + V{1});
cell[11] = -x23*cell[11] - x33*(-x24*(V{3}*x27 + x57 + x61) + V{1});
cell[12] = -x23*cell[12] - x33*(-x24*(V{3}*x29 + x56 + x62 + V{1}) + V{1});
cell[13] = -x23*cell[13] - x38*(-x24*(V{4.5}*x40 + x59 + x61) + V{1});
cell[14] = -x23*cell[14] - x38*(x24*(x53 + x63 - V{4.5}*x43*x43) + V{1});
cell[15] = -x23*cell[15] - x38*(-x24*(V{4.5}*x46 + x59 + x62) + V{1});
cell[16] = -x23*cell[16] - x38*(x24*(x63 + x64 - V{4.5}*x49*x49) + V{1});
cell[17] = -x23*cell[17] - x38*(-x24*(x37 + V{4.5}*x52 + x58 + x61) + V{1});
cell[18] = -x23*cell[18] - x38*(x24*(x42 + x64 - V{4.5}*x54*x54) + V{1});
return { V{1}*x24, x25 + x27 + x29 };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<1,-1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x23 = x22 + V{-1};
auto x24 = x20 + V{-1};
auto x25 = cell[0] + cell[10] + cell[12] + V{2}*cell[14] + cell[15] + cell[16] + cell[1] + V{2}*cell[2] + cell[3] + V{2}*cell[4] + cell[6] + cell[7] + V{2}*cell[8] + V{2}*cell[9] + V{1};
auto x26 = -x25/x24;
auto x27 = x19*x19;
auto x28 = V{1.5}*x27;
auto x29 = x20*x20;
auto x30 = V{1.5}*x29;
auto x31 = x21*x21;
auto x32 = V{1.5}*x31;
auto x33 = x30 + x32 + V{-1};
auto x34 = x28 + x33;
auto x35 = V{0.0555555555555556}*x22;
auto x36 = V{3}*x19;
auto x37 = V{3}*x20;
auto x38 = x28 + V{-1};
auto x39 = V{3}*x21;
auto x40 = V{0.0277777777777778}*x22;
auto x41 = x19 + x20;
auto x42 = x41*x41;
auto x43 = x34 + x36;
auto x44 = -x37;
auto x45 = x19 - x20;
auto x46 = -x45;
auto x47 = x19 + x21;
auto x48 = x47*x47;
auto x49 = -x39;
auto x50 = -x21;
auto x51 = x19 + x50;
auto x52 = -x51;
auto x53 = x20 + x21;
auto x54 = x53*x53;
auto x55 = x34 + x37;
auto x56 = x20 + x50;
auto x57 = -x56;
auto x58 = -x30;
auto x59 = V{1} - x32;
auto x60 = x58 + x59;
auto x61 = x36 + x60;
auto x62 = -x28;
auto x63 = x37 + x62;
auto x64 = x39 + x62;
auto x65 = -x36;
auto x66 = x34 + x39;
cell[0] = -V{0.333333333333333}*x22*(x26*x34 + V{1}) - x23*cell[0];
cell[1] = -x23*cell[1] - x35*(-x26*(V{3}*x27 - x33 - x36) + V{1});
cell[2] = -x23*cell[2] - x35*(-x26*(V{3}*x29 - x32 - x37 - x38) + V{1});
cell[3] = -x23*cell[3] - x35*(-x26*(-x30 + V{3}*x31 - x38 - x39) + V{1});
cell[4] = -x23*cell[4] - x40*(-x26*(-x37 + V{4.5}*x42 - x43) + V{1});
cell[5] = -x23*cell[5] - x40*(x26*(x43 + x44 - V{4.5}*x46*x46) + V{1});
cell[6] = -x23*cell[6] - x40*(-x26*(-x39 - x43 + V{4.5}*x48) + V{1});
cell[7] = -x23*cell[7] - x40*(x26*(x43 + x49 - V{4.5}*x52*x52) + V{1});
cell[8] = -x23*cell[8] - x40*(-x26*(-x39 + V{4.5}*x54 - x55) + V{1});
cell[9] = -x23*cell[9] - x40*(x26*(x49 + x55 - V{4.5}*x57*x57) + V{1});
cell[10] = -x23*cell[10] - x35*(-x26*(V{3}*x27 + x61) + V{1});
cell[11] = -x23*cell[11] - x35*(-x26*(V{3}*x29 + x59 + x63) + V{1});
cell[12] = -x23*cell[12] - x35*(-x26*(V{3}*x31 + x58 + x64 + V{1}) + V{1});
cell[13] = -x23*cell[13] - x40*(-x26*(V{4.5}*x42 + x61 + x63) + V{1});
cell[14] = -x23*cell[14] - x40*(x26*(x55 + x65 - V{4.5}*x45*x45) + V{1});
cell[15] = -x23*cell[15] - x40*(-x26*(V{4.5}*x48 + x61 + x64) + V{1});
cell[16] = -x23*cell[16] - x40*(x26*(x65 + x66 - V{4.5}*x51*x51) + V{1});
cell[17] = -x23*cell[17] - x40*(-x26*(x39 + V{4.5}*x54 + x60 + x63) + V{1});
cell[18] = -x23*cell[18] - x40*(x26*(x44 + x66 - V{4.5}*x56*x56) + V{1});
return { -V{1}*x25/x24, x27 + x29 + x31 };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<1,1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x23 = x22 + V{-1};
auto x24 = (cell[0] + cell[10] + V{2}*cell[11] + cell[12] + V{2}*cell[13] + cell[15] + cell[16] + V{2}*cell[17] + V{2}*cell[18] + cell[1] + cell[3] + V{2}*cell[5] + cell[6] + cell[7] + V{1})/(x20 + V{1});
auto x25 = x19*x19;
auto x26 = V{1.5}*x25;
auto x27 = x20*x20;
auto x28 = V{1.5}*x27;
auto x29 = x21*x21;
auto x30 = V{1.5}*x29;
auto x31 = x28 + x30 + V{-1};
auto x32 = x26 + x31;
auto x33 = V{0.0555555555555556}*x22;
auto x34 = V{3}*x19;
auto x35 = V{3}*x20;
auto x36 = x26 + V{-1};
auto x37 = V{3}*x21;
auto x38 = V{0.0277777777777778}*x22;
auto x39 = x19 + x20;
auto x40 = x39*x39;
auto x41 = x32 + x34;
auto x42 = -x35;
auto x43 = x19 - x20;
auto x44 = -x43;
auto x45 = x19 + x21;
auto x46 = x45*x45;
auto x47 = -x37;
auto x48 = -x21;
auto x49 = x19 + x48;
auto x50 = -x49;
auto x51 = x20 + x21;
auto x52 = x51*x51;
auto x53 = x32 + x35;
auto x54 = x20 + x48;
auto x55 = -x54;
auto x56 = -x28;
auto x57 = V{1} - x30;
auto x58 = x56 + x57;
auto x59 = x34 + x58;
auto x60 = -x26;
auto x61 = x35 + x60;
auto x62 = x37 + x60;
auto x63 = -x34;
auto x64 = x32 + x37;
cell[0] = -V{0.333333333333333}*x22*(x24*x32 + V{1}) - x23*cell[0];
cell[1] = -x23*cell[1] - x33*(-x24*(V{3}*x25 - x31 - x34) + V{1});
cell[2] = -x23*cell[2] - x33*(-x24*(V{3}*x27 - x30 - x35 - x36) + V{1});
cell[3] = -x23*cell[3] - x33*(-x24*(-x28 + V{3}*x29 - x36 - x37) + V{1});
cell[4] = -x23*cell[4] - x38*(-x24*(-x35 + V{4.5}*x40 - x41) + V{1});
cell[5] = -x23*cell[5] - x38*(x24*(x41 + x42 - V{4.5}*x44*x44) + V{1});
cell[6] = -x23*cell[6] - x38*(-x24*(-x37 - x41 + V{4.5}*x46) + V{1});
cell[7] = -x23*cell[7] - x38*(x24*(x41 + x47 - V{4.5}*x50*x50) + V{1});
cell[8] = -x23*cell[8] - x38*(-x24*(-x37 + V{4.5}*x52 - x53) + V{1});
cell[9] = -x23*cell[9] - x38*(x24*(x47 + x53 - V{4.5}*x55*x55) + V{1});
cell[10] = -x23*cell[10] - x33*(-x24*(V{3}*x25 + x59) + V{1});
cell[11] = -x23*cell[11] - x33*(-x24*(V{3}*x27 + x57 + x61) + V{1});
cell[12] = -x23*cell[12] - x33*(-x24*(V{3}*x29 + x56 + x62 + V{1}) + V{1});
cell[13] = -x23*cell[13] - x38*(-x24*(V{4.5}*x40 + x59 + x61) + V{1});
cell[14] = -x23*cell[14] - x38*(x24*(x53 + x63 - V{4.5}*x43*x43) + V{1});
cell[15] = -x23*cell[15] - x38*(-x24*(V{4.5}*x46 + x59 + x62) + V{1});
cell[16] = -x23*cell[16] - x38*(x24*(x63 + x64 - V{4.5}*x49*x49) + V{1});
cell[17] = -x23*cell[17] - x38*(-x24*(x37 + V{4.5}*x52 + x58 + x61) + V{1});
cell[18] = -x23*cell[18] - x38*(x24*(x42 + x64 - V{4.5}*x54*x54) + V{1});
return { V{1}*x24, x25 + x27 + x29 };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<2,-1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x23 = x22 + V{-1};
auto x24 = x21 + V{-1};
auto x25 = cell[0] + cell[10] + cell[11] + cell[13] + cell[14] + V{2}*cell[16] + V{2}*cell[18] + cell[1] + cell[2] + V{2}*cell[3] + cell[4] + cell[5] + V{2}*cell[6] + V{2}*cell[8] + V{1};
auto x26 = -x25/x24;
auto x27 = x19*x19;
auto x28 = V{1.5}*x27;
auto x29 = x20*x20;
auto x30 = V{1.5}*x29;
auto x31 = x21*x21;
auto x32 = V{1.5}*x31;
auto x33 = x30 + x32 + V{-1};
auto x34 = x28 + x33;
auto x35 = V{0.0555555555555556}*x22;
auto x36 = V{3}*x19;
auto x37 = V{3}*x20;
auto x38 = x28 + V{-1};
auto x39 = V{3}*x21;
auto x40 = V{0.0277777777777778}*x22;
auto x41 = x19 + x20;
auto x42 = x41*x41;
auto x43 = x34 + x36;
auto x44 = -x37;
auto x45 = x19 - x20;
auto x46 = -x45;
auto x47 = x19 + x21;
auto x48 = x47*x47;
auto x49 = -x39;
auto x50 = -x21;
auto x51 = x19 + x50;
auto x52 = -x51;
auto x53 = x20 + x21;
auto x54 = x53*x53;
auto x55 = x34 + x37;
auto x56 = x20 + x50;
auto x57 = -x56;
auto x58 = -x30;
auto x59 = V{1} - x32;
auto x60 = x58 + x59;
auto x61 = x36 + x60;
auto x62 = -x28;
auto x63 = x37 + x62;
auto x64 = x39 + x62;
auto x65 = -x36;
auto x66 = x34 + x39;
cell[0] = -V{0.333333333333333}*x22*(x26*x34 + V{1}) - x23*cell[0];
cell[1] = -x23*cell[1] - x35*(-x26*(V{3}*x27 - x33 - x36) + V{1});
cell[2] = -x23*cell[2] - x35*(-x26*(V{3}*x29 - x32 - x37 - x38) + V{1});
cell[3] = -x23*cell[3] - x35*(-x26*(-x30 + V{3}*x31 - x38 - x39) + V{1});
cell[4] = -x23*cell[4] - x40*(-x26*(-x37 + V{4.5}*x42 - x43) + V{1});
cell[5] = -x23*cell[5] - x40*(x26*(x43 + x44 - V{4.5}*x46*x46) + V{1});
cell[6] = -x23*cell[6] - x40*(-x26*(-x39 - x43 + V{4.5}*x48) + V{1});
cell[7] = -x23*cell[7] - x40*(x26*(x43 + x49 - V{4.5}*x52*x52) + V{1});
cell[8] = -x23*cell[8] - x40*(-x26*(-x39 + V{4.5}*x54 - x55) + V{1});
cell[9] = -x23*cell[9] - x40*(x26*(x49 + x55 - V{4.5}*x57*x57) + V{1});
cell[10] = -x23*cell[10] - x35*(-x26*(V{3}*x27 + x61) + V{1});
cell[11] = -x23*cell[11] - x35*(-x26*(V{3}*x29 + x59 + x63) + V{1});
cell[12] = -x23*cell[12] - x35*(-x26*(V{3}*x31 + x58 + x64 + V{1}) + V{1});
cell[13] = -x23*cell[13] - x40*(-x26*(V{4.5}*x42 + x61 + x63) + V{1});
cell[14] = -x23*cell[14] - x40*(x26*(x55 + x65 - V{4.5}*x45*x45) + V{1});
cell[15] = -x23*cell[15] - x40*(-x26*(V{4.5}*x48 + x61 + x64) + V{1});
cell[16] = -x23*cell[16] - x40*(x26*(x65 + x66 - V{4.5}*x51*x51) + V{1});
cell[17] = -x23*cell[17] - x40*(-x26*(x39 + V{4.5}*x54 + x60 + x63) + V{1});
cell[18] = -x23*cell[18] - x40*(x26*(x44 + x66 - V{4.5}*x56*x56) + V{1});
return { -V{1}*x25/x24, x27 + x29 + x31 };
}
 
};
 
template <typename... FIELDS>
struct BGK::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<2,1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x23 = x22 + V{-1};
auto x24 = (cell[0] + cell[10] + cell[11] + V{2}*cell[12] + cell[13] + cell[14] + V{2}*cell[15] + V{2}*cell[17] + cell[1] + cell[2] + cell[4] + cell[5] + V{2}*cell[7] + V{2}*cell[9] + V{1})/(x21 + V{1});
auto x25 = x19*x19;
auto x26 = V{1.5}*x25;
auto x27 = x20*x20;
auto x28 = V{1.5}*x27;
auto x29 = x21*x21;
auto x30 = V{1.5}*x29;
auto x31 = x28 + x30 + V{-1};
auto x32 = x26 + x31;
auto x33 = V{0.0555555555555556}*x22;
auto x34 = V{3}*x19;
auto x35 = V{3}*x20;
auto x36 = x26 + V{-1};
auto x37 = V{3}*x21;
auto x38 = V{0.0277777777777778}*x22;
auto x39 = x19 + x20;
auto x40 = x39*x39;
auto x41 = x32 + x34;
auto x42 = -x35;
auto x43 = x19 - x20;
auto x44 = -x43;
auto x45 = x19 + x21;
auto x46 = x45*x45;
auto x47 = -x37;
auto x48 = -x21;
auto x49 = x19 + x48;
auto x50 = -x49;
auto x51 = x20 + x21;
auto x52 = x51*x51;
auto x53 = x32 + x35;
auto x54 = x20 + x48;
auto x55 = -x54;
auto x56 = -x28;
auto x57 = V{1} - x30;
auto x58 = x56 + x57;
auto x59 = x34 + x58;
auto x60 = -x26;
auto x61 = x35 + x60;
auto x62 = x37 + x60;
auto x63 = -x34;
auto x64 = x32 + x37;
cell[0] = -V{0.333333333333333}*x22*(x24*x32 + V{1}) - x23*cell[0];
cell[1] = -x23*cell[1] - x33*(-x24*(V{3}*x25 - x31 - x34) + V{1});
cell[2] = -x23*cell[2] - x33*(-x24*(V{3}*x27 - x30 - x35 - x36) + V{1});
cell[3] = -x23*cell[3] - x33*(-x24*(-x28 + V{3}*x29 - x36 - x37) + V{1});
cell[4] = -x23*cell[4] - x38*(-x24*(-x35 + V{4.5}*x40 - x41) + V{1});
cell[5] = -x23*cell[5] - x38*(x24*(x41 + x42 - V{4.5}*x44*x44) + V{1});
cell[6] = -x23*cell[6] - x38*(-x24*(-x37 - x41 + V{4.5}*x46) + V{1});
cell[7] = -x23*cell[7] - x38*(x24*(x41 + x47 - V{4.5}*x50*x50) + V{1});
cell[8] = -x23*cell[8] - x38*(-x24*(-x37 + V{4.5}*x52 - x53) + V{1});
cell[9] = -x23*cell[9] - x38*(x24*(x47 + x53 - V{4.5}*x55*x55) + V{1});
cell[10] = -x23*cell[10] - x33*(-x24*(V{3}*x25 + x59) + V{1});
cell[11] = -x23*cell[11] - x33*(-x24*(V{3}*x27 + x57 + x61) + V{1});
cell[12] = -x23*cell[12] - x33*(-x24*(V{3}*x29 + x56 + x62 + V{1}) + V{1});
cell[13] = -x23*cell[13] - x38*(-x24*(V{4.5}*x40 + x59 + x61) + V{1});
cell[14] = -x23*cell[14] - x38*(x24*(x53 + x63 - V{4.5}*x43*x43) + V{1});
cell[15] = -x23*cell[15] - x38*(-x24*(V{4.5}*x46 + x59 + x62) + V{1});
cell[16] = -x23*cell[16] - x38*(x24*(x63 + x64 - V{4.5}*x49*x49) + V{1});
cell[17] = -x23*cell[17] - x38*(-x24*(x37 + V{4.5}*x52 + x58 + x61) + V{1});
cell[18] = -x23*cell[18] - x38*(x24*(x42 + x64 - V{4.5}*x54*x54) + V{1});
return { V{1}*x24, x25 + x27 + x29 };
}
 
};
 
 
template <typename... FIELDS>
struct RLB::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<0,-1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x23 = x22 + V{-1};
auto x24 = V{1} / (x19 + V{-1});
auto x25 = V{2}*cell[4] + V{2}*cell[5] + V{2}*cell[6] + V{2}*cell[7];
auto x26 = x25 + cell[0] + cell[11] + cell[12] + cell[17] + cell[18] + V{2}*cell[1] + cell[2] + cell[3] + cell[8] + cell[9] + V{1};
auto x27 = x24*x26;
auto x28 = V{0.0555555555555556}*x27;
auto x29 = x20*x20;
auto x30 = V{1.5}*x29;
auto x31 = V{3}*x19;
auto x32 = x19*x19;
auto x33 = V{3}*x32;
auto x34 = x21*x21;
auto x35 = V{1.5}*x34;
auto x36 = x35 + V{-1};
auto x37 = x30 + x31 - x33 + x36;
auto x38 = -x28*x37;
auto x39 = V{0.0277777777777778}*x27;
auto x40 = V{3}*x21;
auto x41 = x20 + x21;
auto x42 = V{4.5}*(x41*x41);
auto x43 = V{3}*x20;
auto x44 = V{1.5}*x32;
auto x45 = x30 + x44 + V{-1};
auto x46 = x35 + x45;
auto x47 = x43 + x46;
auto x48 = x40 - x42 + x47;
auto x49 = -x39*x48;
auto x50 = -x40;
auto x51 = -x21;
auto x52 = x20 + x51;
auto x53 = -x52;
auto x54 = x47 + x50 - V{4.5}*x53*x53;
auto x55 = -x39*x54;
auto x56 = -x35;
auto x57 = V{1} - x44;
auto x58 = x56 + x57;
auto x59 = x43 + x58;
auto x60 = -x30;
auto x61 = x40 + x60;
auto x62 = x42 + x59 + x61;
auto x63 = x39*x62;
auto x64 = -x43;
auto x65 = x40 + x46;
auto x66 = x64 + x65 - V{4.5}*x52*x52;
auto x67 = -x39*x66;
auto x68 = V{3}*x29;
auto x69 = x59 + x68;
auto x70 = V{3}*x34;
auto x71 = x57 + x61 + x70;
auto x72 = x40 + x45 - x70;
auto x73 = x36 + x43 + x44 - x68;
auto x74 = x19 + x20;
auto x75 = V{4.5}*(x74*x74);
auto x76 = x31 + x47 - x75;
auto x77 = x19 + x21;
auto x78 = V{4.5}*(x77*x77);
auto x79 = x31 + x65 - x78;
auto x80 = x19 - x20;
auto x81 = -x80;
auto x82 = x31 + x46;
auto x83 = x64 + x82 - V{4.5}*x81*x81;
auto x84 = x19 + x51;
auto x85 = -x84;
auto x86 = x50 + x82 - V{4.5}*x85*x85;
auto x87 = V{0.0833333333333333}*cell[2];
auto x88 = V{0.0833333333333333}*cell[3];
auto x89 = V{0.0833333333333333}*cell[11];
auto x90 = V{0.0833333333333333}*cell[12];
auto x91 = V{0.00462962962962963}*x27;
auto x92 = x69*x91;
auto x93 = x71*x91;
auto x94 = V{0.00462962962962963}*x27;
auto x95 = x76*x94;
auto x96 = x79*x94;
auto x97 = x83*x94;
auto x98 = x86*x94;
auto x99 = x23*(V{0.00462962962962963}*x24*x26*x48 + V{0.00462962962962963}*x24*x26*x54 + V{0.00462962962962963}*x24*x26*x66 + V{0.00462962962962963}*x24*x26*x72 + V{0.00462962962962963}*x24*x26*x73 - V{0.0185185185185185}*x27*x37 - x62*x91 - x87 - x88 - x89 - x90 - x92 - x93 - x95 - x96 - x97 - x98 - V{0.166666666666667}*cell[17] - V{0.166666666666667}*cell[18] + V{0.333333333333333}*cell[1] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7] - V{0.166666666666667}*cell[8] - V{0.166666666666667}*cell[9] + V{6.93889390390723e-18}) + V{0.0555555555555556};
auto x100 = V{0.00925925925925926}*x27;
auto x101 = V{0.00925925925925926}*x27;
auto x102 = V{0.00231481481481482}*x27;
auto x103 = x100*x37 - x102*x48 - x102*x54 + x102*x62 - x102*x66 + V{0.0833333333333334}*cell[17] + V{0.0833333333333334}*cell[18] - V{0.166666666666667}*cell[1] + V{0.0833333333333334}*cell[8] + V{0.0833333333333334}*cell[9] + V{6.93889390390723e-18};
auto x104 = x23*(x100*x79 + x100*x86 + x101*x69 - x101*x73 + x103 + x72*x91 - x88 - x90 - x93 - x95 - x97 + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[2] + V{0.166666666666667}*cell[4] + V{0.166666666666667}*cell[5] - V{0.333333333333333}*cell[6] - V{0.333333333333333}*cell[7]) + V{0.0555555555555556};
auto x105 = x23*(x100*x76 + x100*x83 + x101*x71 - x101*x72 + x103 + x73*x91 - x87 - x89 - x92 - x96 - x98 + V{0.166666666666667}*cell[12] + V{0.166666666666667}*cell[3] - V{0.333333333333333}*cell[4] - V{0.333333333333333}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[7]) + V{0.0555555555555556};
auto x106 = V{0.00462962962962963}*x27;
auto x107 = V{0.0231481481481481}*x27;
auto x108 = V{0.00231481481481481}*x27;
auto x109 = V{0.00462962962962963}*x27;
auto x110 = -x102*x79 - x102*x86 + x109*x69 - x109*x73 + V{0.0833333333333333}*cell[11] + V{0.0833333333333333}*cell[2] + V{0.0833333333333334}*cell[6] + V{0.0833333333333334}*cell[7] + V{0.0416666666666667};
auto x111 = V{0.00115740740740741}*x27;
auto x112 = -x101*x37 - x111*x48 - x111*x54 + x111*x62 - x111*x66 + V{0.0416666666666667}*cell[17] + V{0.0416666666666667}*cell[18] + V{0.166666666666667}*cell[1] + V{0.0416666666666667}*cell[8] + V{0.0416666666666667}*cell[9];
auto x113 = -x108*x71 + x108*x72 + x110 + x112 - V{0.0416666666666667}*cell[12] - V{0.0416666666666667}*cell[3];
auto x114 = x23*(x106*x83 - x107*x76 + x113 + V{0.833333333333333}*cell[4] - V{0.166666666666667}*cell[5]) + V{0.0277777777777778};
auto x115 = x23*(x106*x76 - x107*x83 + x113 - V{0.166666666666667}*cell[4] + V{0.833333333333333}*cell[5]) + V{0.0277777777777778};
auto x116 = -x102*x76 - x102*x83 + x109*x71 - x109*x72 + V{0.0833333333333333}*cell[12] + V{0.0833333333333333}*cell[3] + V{0.0833333333333334}*cell[4] + V{0.0833333333333334}*cell[5];
auto x117 = -x108*x69 + x108*x73 + x112 + x116 - V{0.0416666666666667}*cell[11] - V{0.0416666666666667}*cell[2] + V{0.0416666666666667};
auto x118 = x23*(x106*x86 - x107*x79 + x117 + V{0.833333333333333}*cell[6] - V{0.166666666666667}*cell[7]) + V{0.0277777777777778};
auto x119 = x23*(x106*x79 - x107*x86 + x117 - V{0.166666666666667}*cell[6] + V{0.833333333333333}*cell[7]) + V{0.0277777777777778};
auto x120 = V{0.0115740740740741}*x27;
auto x121 = V{0.00231481481481481}*x27;
auto x122 = x110 + x116 + x37*x91 - V{0.0833333333333333}*cell[1];
auto x123 = x23*(-x120*x48 + x120*x62 + x121*x54 + x121*x66 + x122 + V{0.416666666666667}*cell[17] - V{0.0833333333333333}*cell[18] + V{0.416666666666667}*cell[8] - V{0.0833333333333333}*cell[9]) + V{0.0277777777777778};
auto x124 = x23*(-x120*x54 - x120*x66 + x121*x48 - x121*x62 + x122 - V{0.0833333333333333}*cell[17] + V{0.416666666666667}*cell[18] - V{0.0833333333333333}*cell[8] + V{0.416666666666667}*cell[9]) + V{0.0277777777777778};
auto x125 = x31 + x60;
auto x126 = -x31;
auto x0 = x23*(x25 - x28*x76 - x28*x79 - x28*x83 - x28*x86 + x38 + x39*x69 + x39*x71 - x39*x72 - x39*x73 + x49 + x55 + x63 + x67 + V{0.5}*cell[11] + V{0.5}*cell[12] + V{1}*cell[17] + V{1}*cell[18] + V{1}*cell[1] + V{0.5}*cell[2] + V{0.5}*cell[3] + V{1}*cell[8] + V{1}*cell[9] + V{0.5}) + V{0.333333333333333}*x27*x46 + V{-0.333333333333333};
auto x1 = -x38 - x99;
auto x2 = -x104 + V{0.0555555555555556}*x24*x26*x73;
auto x3 = -x105 + V{0.0555555555555556}*x24*x26*x72;
auto x4 = -x114 + V{0.0277777777777778}*x24*x26*x76;
auto x5 = -x115 + V{0.0277777777777778}*x24*x26*x83;
auto x6 = -x118 + V{0.0277777777777778}*x24*x26*x79;
auto x7 = -x119 + V{0.0277777777777778}*x24*x26*x86;
auto x8 = -x123 - x49;
auto x9 = -x124 - x55;
auto x10 = -x28*(x125 + x33 + x56 + V{1}) - x99;
auto x11 = -x104 - x28*x69;
auto x12 = -x105 - x28*x71;
auto x13 = -x114 - x39*(x125 + x59 + x75);
auto x14 = -x115 + V{0.0277777777777778}*x24*x26*(x126 + x47 - V{4.5}*x80*x80);
auto x15 = -x118 - x39*(x31 + x58 + x61 + x78);
auto x16 = -x119 + V{0.0277777777777778}*x24*x26*(x126 + x65 - V{4.5}*x84*x84);
auto x17 = -x123 - x63;
auto x18 = -x124 - x67;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { -V{1}*x27, x29 + x32 + x34 };
}
 
};
 
template <typename... FIELDS>
struct RLB::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<0,1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x23 = x22 + V{-1};
auto x24 = V{1} / (x19 + V{1});
auto x25 = V{2}*cell[13] + V{2}*cell[14] + V{2}*cell[15] + V{2}*cell[16];
auto x26 = x25 + cell[0] + V{2}*cell[10] + cell[11] + cell[12] + cell[17] + cell[18] + cell[2] + cell[3] + cell[8] + cell[9] + V{1};
auto x27 = x24*x26;
auto x28 = V{0.0555555555555556}*x27;
auto x29 = x21*x21;
auto x30 = V{1.5}*x29;
auto x31 = -x30;
auto x32 = x19*x19;
auto x33 = V{3}*x32;
auto x34 = x20*x20;
auto x35 = V{1.5}*x34;
auto x36 = -x35;
auto x37 = V{3}*x19;
auto x38 = x36 + x37;
auto x39 = x31 + x33 + x38 + V{1};
auto x40 = -x28*x39;
auto x41 = V{0.0277777777777778}*x27;
auto x42 = x20 + x21;
auto x43 = x42*x42;
auto x44 = V{3}*x20;
auto x45 = V{1.5}*x32;
auto x46 = V{1} - x45;
auto x47 = x31 + x46;
auto x48 = x44 + x47;
auto x49 = V{3}*x21;
auto x50 = x36 + x49;
auto x51 = V{4.5}*x43 + x48 + x50;
auto x52 = -x41*x51;
auto x53 = V{3}*x34 + x48;
auto x54 = V{3}*x29 + x46 + x50;
auto x55 = x30 + x45 + V{-1};
auto x56 = -V{3}*x34 + x44 + x55;
auto x57 = x35 + V{-1};
auto x58 = -V{3}*x29 + x45 + x49 + x57;
auto x59 = -x44;
auto x60 = -x21;
auto x61 = x20 + x60;
auto x62 = x35 + x55;
auto x63 = x49 + x62;
auto x64 = x59 + x63 - V{4.5}*x61*x61;
auto x65 = -x49;
auto x66 = -x61;
auto x67 = x44 + x62;
auto x68 = x65 + x67 - V{4.5}*x66*x66;
auto x69 = -V{4.5}*x43 + x44 + x63;
auto x70 = x19 + x20;
auto x71 = V{4.5}*(x70*x70);
auto x72 = x38 + x48 + x71;
auto x73 = x19 + x21;
auto x74 = V{4.5}*(x73*x73);
auto x75 = x37 + x47 + x50 + x74;
auto x76 = -V{3}*x19;
auto x77 = x19 - x20;
auto x78 = x67 + x76 - V{4.5}*x77*x77;
auto x79 = x19 + x60;
auto x80 = x63 + x76 - V{4.5}*x79*x79;
auto x81 = V{0.0833333333333333}*cell[2];
auto x82 = V{0.0833333333333333}*cell[3];
auto x83 = V{0.0833333333333333}*cell[11];
auto x84 = V{0.0833333333333333}*cell[12];
auto x85 = V{0.00462962962962963}*x27;
auto x86 = x58*x85;
auto x87 = x56*x85;
auto x88 = V{0.00462962962962963}*x27;
auto x89 = x72*x88;
auto x90 = x75*x88;
auto x91 = x23*(V{0.00462962962962963}*x24*x26*x51 + V{0.00462962962962963}*x24*x26*x53 + V{0.00462962962962963}*x24*x26*x54 + V{0.00462962962962963}*x24*x26*x78 + V{0.00462962962962963}*x24*x26*x80 - V{0.0185185185185185}*x27*x39 - x64*x85 - x68*x85 - x69*x85 - x81 - x82 - x83 - x84 - x86 - x87 - x89 - x90 + V{0.333333333333333}*cell[10] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] - V{0.166666666666667}*cell[17] - V{0.166666666666667}*cell[18] - V{0.166666666666667}*cell[8] - V{0.166666666666667}*cell[9] + V{6.93889390390723e-18}) + V{0.0555555555555556};
auto x92 = V{0.00925925925925926}*x27;
auto x93 = V{0.00925925925925926}*x27;
auto x94 = V{0.00231481481481482}*x27;
auto x95 = x39*x92 - x51*x94 + x64*x94 + x68*x94 + x69*x94 - V{0.166666666666667}*cell[10] + V{0.0833333333333334}*cell[17] + V{0.0833333333333334}*cell[18] + V{0.0833333333333334}*cell[8] + V{0.0833333333333334}*cell[9] + V{6.93889390390723e-18};
auto x96 = x23*(-x53*x93 + x54*x85 + x56*x93 + x75*x92 + x78*x88 - x80*x92 - x82 - x84 - x86 - x89 + x95 + V{0.166666666666667}*cell[11] + V{0.166666666666667}*cell[13] + V{0.166666666666667}*cell[14] - V{0.333333333333333}*cell[15] - V{0.333333333333333}*cell[16] + V{0.166666666666667}*cell[2]) + V{0.0555555555555556};
auto x97 = x23*(x53*x85 - x54*x93 + x58*x93 + x72*x92 - x78*x92 + x80*x88 - x81 - x83 - x87 - x90 + x95 + V{0.166666666666667}*cell[12] - V{0.333333333333333}*cell[13] - V{0.333333333333333}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[3]) + V{0.0555555555555556};
auto x98 = V{0.0231481481481481}*x27;
auto x99 = V{0.00462962962962963}*x27;
auto x100 = V{0.00231481481481481}*x27;
auto x101 = V{0.00462962962962963}*x27;
auto x102 = -x101*x53 + x101*x56 - x75*x94 + x80*x94 + V{0.0833333333333333}*cell[11] + V{0.0833333333333334}*cell[15] + V{0.0833333333333334}*cell[16] + V{0.0833333333333333}*cell[2] + V{0.0416666666666667};
auto x103 = V{0.00115740740740741}*x27;
auto x104 = -x103*x51 + x103*x64 + x103*x68 + x103*x69 - x39*x93 + V{0.166666666666667}*cell[10] + V{0.0416666666666667}*cell[17] + V{0.0416666666666667}*cell[18] + V{0.0416666666666667}*cell[8] + V{0.0416666666666667}*cell[9];
auto x105 = x100*x54 - x100*x58 + x102 + x104 - V{0.0416666666666667}*cell[12] - V{0.0416666666666667}*cell[3];
auto x106 = x23*(x105 - x72*x98 - x78*x99 + V{0.833333333333333}*cell[13] - V{0.166666666666667}*cell[14]) + V{0.0277777777777778};
auto x107 = -x77;
auto x108 = x37 + x62;
auto x109 = x23*(x105 + x72*x99 + x78*x98 - V{0.166666666666667}*cell[13] + V{0.833333333333333}*cell[14]) + V{0.0277777777777778};
auto x110 = -x101*x54 + x101*x58 - x72*x94 + x78*x94 + V{0.0833333333333333}*cell[12] + V{0.0833333333333334}*cell[13] + V{0.0833333333333334}*cell[14] + V{0.0833333333333333}*cell[3];
auto x111 = x100*x53 - x100*x56 + x104 + x110 - V{0.0416666666666667}*cell[11] - V{0.0416666666666667}*cell[2] + V{0.0416666666666667};
auto x112 = x23*(x111 - x75*x98 - x80*x99 + V{0.833333333333333}*cell[15] - V{0.166666666666667}*cell[16]) + V{0.0277777777777778};
auto x113 = -x79;
auto x114 = x23*(x111 + x75*x99 + x80*x98 - V{0.166666666666667}*cell[15] + V{0.833333333333333}*cell[16]) + V{0.0277777777777778};
auto x115 = V{0.0115740740740741}*x27;
auto x116 = V{0.00231481481481481}*x27;
auto x117 = x102 + x110 + x39*x85 - V{0.0833333333333333}*cell[10];
auto x118 = x23*(-x115*x51 + x115*x69 - x116*x64 - x116*x68 + x117 + V{0.416666666666667}*cell[17] - V{0.0833333333333333}*cell[18] + V{0.416666666666667}*cell[8] - V{0.0833333333333333}*cell[9]) + V{0.0277777777777778};
auto x119 = x23*(x115*x64 + x115*x68 + x116*x51 - x116*x69 + x117 - V{0.0833333333333333}*cell[17] + V{0.416666666666667}*cell[18] - V{0.0833333333333333}*cell[8] + V{0.416666666666667}*cell[9]) + V{0.0277777777777778};
auto x0 = x23*(x25 - x28*x72 - x28*x75 + x28*x78 + x28*x80 + x40 - x41*x53 - x41*x54 + x41*x56 + x41*x58 + x41*x64 + x41*x68 + x41*x69 + x52 + V{1}*cell[10] + V{0.5}*cell[11] + V{0.5}*cell[12] + V{1}*cell[17] + V{1}*cell[18] + V{0.5}*cell[2] + V{0.5}*cell[3] + V{1}*cell[8] + V{1}*cell[9] + V{0.5}) - V{0.333333333333333}*x27*x62 + V{-0.333333333333333};
auto x1 = -x28*(x30 - x33 + x37 + x57) - x91;
auto x2 = -x28*x56 - x96;
auto x3 = -x28*x58 - x97;
auto x4 = -x106 - x41*(x37 + x67 - x71);
auto x5 = -x109 - x41*(x108 + x59 - V{4.5}*x107*x107);
auto x6 = -x112 - x41*(x37 + x63 - x74);
auto x7 = -x114 - x41*(x108 + x65 - V{4.5}*x113*x113);
auto x8 = -x118 - x41*x69;
auto x9 = -x119 - x41*x68;
auto x10 = -x40 - x91;
auto x11 = V{0.0555555555555556}*x24*x26*x53 - x96;
auto x12 = V{0.0555555555555556}*x24*x26*x54 - x97;
auto x13 = -x106 + V{0.0277777777777778}*x24*x26*x72;
auto x14 = -x109 - x41*x78;
auto x15 = -x112 + V{0.0277777777777778}*x24*x26*x75;
auto x16 = -x114 - x41*x80;
auto x17 = -x118 - x52;
auto x18 = -x119 - x41*x64;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { V{1}*x27, x29 + x32 + x34 };
}
 
};
 
template <typename... FIELDS>
struct RLB::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<1,-1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x23 = x22 + V{-1};
auto x24 = V{1} / (x20 + V{-1});
auto x25 = V{2}*cell[14] + V{2}*cell[4] + V{2}*cell[8] + V{2}*cell[9];
auto x26 = x25 + cell[0] + cell[10] + cell[12] + cell[15] + cell[16] + cell[1] + V{2}*cell[2] + cell[3] + cell[6] + cell[7] + V{1};
auto x27 = x24*x26;
auto x28 = V{0.0555555555555556}*x27;
auto x29 = x19*x19;
auto x30 = V{1.5}*x29;
auto x31 = V{3}*x20;
auto x32 = x20*x20;
auto x33 = V{3}*x32;
auto x34 = x21*x21;
auto x35 = V{1.5}*x34;
auto x36 = x35 + V{-1};
auto x37 = x30 + x31 - x33 + x36;
auto x38 = -x28*x37;
auto x39 = V{0.0277777777777778}*x27;
auto x40 = V{3}*x21;
auto x41 = x19 + x21;
auto x42 = V{4.5}*(x41*x41);
auto x43 = V{3}*x19;
auto x44 = V{1.5}*x32;
auto x45 = x30 + x44 + V{-1};
auto x46 = x35 + x45;
auto x47 = x43 + x46;
auto x48 = x40 - x42 + x47;
auto x49 = -x39*x48;
auto x50 = -x40;
auto x51 = -x21;
auto x52 = x19 + x51;
auto x53 = -x52;
auto x54 = x47 + x50 - V{4.5}*x53*x53;
auto x55 = -x39*x54;
auto x56 = -x35;
auto x57 = V{1} - x44;
auto x58 = x56 + x57;
auto x59 = x43 + x58;
auto x60 = -x30;
auto x61 = x40 + x60;
auto x62 = x42 + x59 + x61;
auto x63 = x39*x62;
auto x64 = -x43;
auto x65 = x40 + x46;
auto x66 = x64 + x65 - V{4.5}*x52*x52;
auto x67 = -x39*x66;
auto x68 = V{3}*x29;
auto x69 = x59 + x68;
auto x70 = V{3}*x34;
auto x71 = x57 + x61 + x70;
auto x72 = x40 + x45 - x70;
auto x73 = x36 + x43 + x44 - x68;
auto x74 = x19 + x20;
auto x75 = V{4.5}*(x74*x74);
auto x76 = x31 + x47 - x75;
auto x77 = x20 + x21;
auto x78 = V{4.5}*(x77*x77);
auto x79 = x31 + x65 - x78;
auto x80 = x19 - x20;
auto x81 = x31 + x46;
auto x82 = x64 + x81 - V{4.5}*x80*x80;
auto x83 = x20 + x51;
auto x84 = -x83;
auto x85 = x50 + x81 - V{4.5}*x84*x84;
auto x86 = V{0.0833333333333333}*cell[3];
auto x87 = V{0.0833333333333333}*cell[12];
auto x88 = V{0.00462962962962963}*x27;
auto x89 = V{0.00925925925925926}*x27;
auto x90 = V{0.00925925925925926}*x27;
auto x91 = x71*x88;
auto x92 = V{0.00462962962962963}*x27;
auto x93 = x76*x92;
auto x94 = x82*x92;
auto x95 = V{0.00231481481481482}*x27;
auto x96 = x37*x89 - x48*x95 - x54*x95 + x62*x95 - x66*x95 + V{0.0833333333333334}*cell[15] + V{0.0833333333333334}*cell[16] - V{0.166666666666667}*cell[2] + V{0.0833333333333334}*cell[6] + V{0.0833333333333334}*cell[7] + V{6.93889390390723e-18};
auto x97 = x23*(x69*x90 + x72*x88 - x73*x90 + x79*x89 + x85*x89 - x86 - x87 - x91 - x93 - x94 + x96 + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[4] - V{0.333333333333333}*cell[8] - V{0.333333333333333}*cell[9]) + V{0.0555555555555556};
auto x98 = V{0.0833333333333333}*cell[1];
auto x99 = V{0.0833333333333333}*cell[10];
auto x100 = x69*x88;
auto x101 = x79*x92;
auto x102 = x85*x92;
auto x103 = x23*(-x100 - x101 - x102 + V{0.00462962962962963}*x24*x26*x48 + V{0.00462962962962963}*x24*x26*x54 + V{0.00462962962962963}*x24*x26*x66 + V{0.00462962962962963}*x24*x26*x72 + V{0.00462962962962963}*x24*x26*x73 - V{0.0185185185185185}*x27*x37 - x62*x88 - x86 - x87 - x91 - x93 - x94 - x98 - x99 + V{0.166666666666667}*cell[14] - V{0.166666666666667}*cell[15] - V{0.166666666666667}*cell[16] + V{0.333333333333333}*cell[2] + V{0.166666666666667}*cell[4] - V{0.166666666666667}*cell[6] - V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9] + V{6.93889390390723e-18}) + V{0.0555555555555556};
auto x104 = x23*(-x100 - x101 - x102 + x71*x90 - x72*x90 + x73*x88 + x76*x89 + x82*x89 + x96 - x98 - x99 + V{0.166666666666667}*cell[12] - V{0.333333333333333}*cell[14] + V{0.166666666666667}*cell[3] - V{0.333333333333333}*cell[4] + V{0.166666666666667}*cell[8] + V{0.166666666666667}*cell[9]) + V{0.0555555555555556};
auto x105 = V{0.00462962962962963}*x27;
auto x106 = V{0.0231481481481481}*x27;
auto x107 = V{0.00231481481481481}*x27;
auto x108 = V{0.00462962962962963}*x27;
auto x109 = x108*x69 - x108*x73 - x79*x95 - x85*x95 + V{0.0833333333333333}*cell[10] + V{0.0833333333333333}*cell[1] + V{0.0833333333333334}*cell[8] + V{0.0833333333333334}*cell[9] + V{0.0416666666666667};
auto x110 = V{0.00115740740740741}*x27;
auto x111 = -x110*x48 - x110*x54 + x110*x62 - x110*x66 - x37*x90 + V{0.0416666666666667}*cell[15] + V{0.0416666666666667}*cell[16] + V{0.166666666666667}*cell[2] + V{0.0416666666666667}*cell[6] + V{0.0416666666666667}*cell[7];
auto x112 = -x107*x71 + x107*x72 + x109 + x111 - V{0.0416666666666667}*cell[12] - V{0.0416666666666667}*cell[3];
auto x113 = x23*(x105*x82 - x106*x76 + x112 - V{0.166666666666667}*cell[14] + V{0.833333333333333}*cell[4]) + V{0.0277777777777778};
auto x114 = -x31;
auto x115 = -x80;
auto x116 = x23*(x105*x76 - x106*x82 + x112 + V{0.833333333333333}*cell[14] - V{0.166666666666667}*cell[4]) + V{0.0277777777777778};
auto x117 = V{0.0115740740740741}*x27;
auto x118 = V{0.00231481481481481}*x27;
auto x119 = x108*x71 - x108*x72 - x76*x95 - x82*x95 + V{0.0833333333333333}*cell[12] + V{0.0833333333333334}*cell[14] + V{0.0833333333333333}*cell[3] + V{0.0833333333333334}*cell[4];
auto x120 = x109 + x119 + x37*x88 - V{0.0833333333333333}*cell[2];
auto x121 = x23*(-x117*x48 + x117*x62 + x118*x54 + x118*x66 + x120 + V{0.416666666666667}*cell[15] - V{0.0833333333333333}*cell[16] + V{0.416666666666667}*cell[6] - V{0.0833333333333333}*cell[7]) + V{0.0277777777777778};
auto x122 = x23*(-x117*x54 - x117*x66 + x118*x48 - x118*x62 + x120 - V{0.0833333333333333}*cell[15] + V{0.416666666666667}*cell[16] - V{0.0833333333333333}*cell[6] + V{0.416666666666667}*cell[7]) + V{0.0277777777777778};
auto x123 = -x107*x69 + x107*x73 + x111 + x119 - V{0.0416666666666667}*cell[10] - V{0.0416666666666667}*cell[1] + V{0.0416666666666667};
auto x124 = x23*(x105*x85 - x106*x79 + x123 + V{0.833333333333333}*cell[8] - V{0.166666666666667}*cell[9]) + V{0.0277777777777778};
auto x125 = x23*(x105*x79 - x106*x85 + x123 - V{0.166666666666667}*cell[8] + V{0.833333333333333}*cell[9]) + V{0.0277777777777778};
auto x126 = x31 + x60;
auto x0 = x23*(x25 - x28*x76 - x28*x79 - x28*x82 - x28*x85 + x38 + x39*x69 + x39*x71 - x39*x72 - x39*x73 + x49 + x55 + x63 + x67 + V{0.5}*cell[10] + V{0.5}*cell[12] + V{1}*cell[15] + V{1}*cell[16] + V{0.5}*cell[1] + V{1}*cell[2] + V{0.5}*cell[3] + V{1}*cell[6] + V{1}*cell[7] + V{0.5}) + V{0.333333333333333}*x27*x46 + V{-0.333333333333333};
auto x1 = V{0.0555555555555556}*x24*x26*x73 - x97;
auto x2 = -x103 - x38;
auto x3 = -x104 + V{0.0555555555555556}*x24*x26*x72;
auto x4 = -x113 + V{0.0277777777777778}*x24*x26*x76;
auto x5 = -x116 + V{0.0277777777777778}*x24*x26*(x114 + x47 - V{4.5}*x115*x115);
auto x6 = -x121 - x49;
auto x7 = -x122 - x55;
auto x8 = -x124 + V{0.0277777777777778}*x24*x26*x79;
auto x9 = -x125 + V{0.0277777777777778}*x24*x26*x85;
auto x10 = -x28*x69 - x97;
auto x11 = -x103 - x28*(x126 + x33 + x56 + V{1});
auto x12 = -x104 - x28*x71;
auto x13 = -x113 - x39*(x126 + x59 + x75);
auto x14 = -x116 + V{0.0277777777777778}*x24*x26*x82;
auto x15 = -x121 - x63;
auto x16 = -x122 - x67;
auto x17 = -x124 - x39*(x31 + x58 + x61 + x78);
auto x18 = -x125 + V{0.0277777777777778}*x24*x26*(x114 + x65 - V{4.5}*x83*x83);
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { -V{1}*x27, x29 + x32 + x34 };
}
 
};
 
template <typename... FIELDS>
struct RLB::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<1,1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x23 = x22 + V{-1};
auto x24 = V{1} / (x20 + V{1});
auto x25 = V{2}*cell[13] + V{2}*cell[17] + V{2}*cell[18] + V{2}*cell[5];
auto x26 = x25 + cell[0] + cell[10] + V{2}*cell[11] + cell[12] + cell[15] + cell[16] + cell[1] + cell[3] + cell[6] + cell[7] + V{1};
auto x27 = x24*x26;
auto x28 = V{0.0555555555555556}*x27;
auto x29 = x21*x21;
auto x30 = V{1.5}*x29;
auto x31 = -x30;
auto x32 = x20*x20;
auto x33 = V{3}*x32;
auto x34 = x19*x19;
auto x35 = V{1.5}*x34;
auto x36 = -x35;
auto x37 = V{3}*x20;
auto x38 = x36 + x37;
auto x39 = x31 + x33 + x38 + V{1};
auto x40 = -x28*x39;
auto x41 = V{0.0277777777777778}*x27;
auto x42 = x19 + x21;
auto x43 = x42*x42;
auto x44 = V{3}*x19;
auto x45 = V{1.5}*x32;
auto x46 = V{1} - x45;
auto x47 = x31 + x46;
auto x48 = x44 + x47;
auto x49 = V{3}*x21;
auto x50 = x36 + x49;
auto x51 = V{4.5}*x43 + x48 + x50;
auto x52 = -x41*x51;
auto x53 = V{3}*x34 + x48;
auto x54 = V{3}*x29 + x46 + x50;
auto x55 = x30 + x45 + V{-1};
auto x56 = -V{3}*x34 + x44 + x55;
auto x57 = x35 + V{-1};
auto x58 = -V{3}*x29 + x45 + x49 + x57;
auto x59 = -x44;
auto x60 = -x21;
auto x61 = x19 + x60;
auto x62 = x35 + x55;
auto x63 = x49 + x62;
auto x64 = x59 + x63 - V{4.5}*x61*x61;
auto x65 = -x49;
auto x66 = -x61;
auto x67 = x44 + x62;
auto x68 = x65 + x67 - V{4.5}*x66*x66;
auto x69 = -V{4.5}*x43 + x44 + x63;
auto x70 = x19 + x20;
auto x71 = V{4.5}*(x70*x70);
auto x72 = x38 + x48 + x71;
auto x73 = x20 + x21;
auto x74 = V{4.5}*(x73*x73);
auto x75 = x37 + x47 + x50 + x74;
auto x76 = -V{3}*x20;
auto x77 = x19 - x20;
auto x78 = -x77;
auto x79 = x67 + x76 - V{4.5}*x78*x78;
auto x80 = x20 + x60;
auto x81 = x63 + x76 - V{4.5}*x80*x80;
auto x82 = V{0.0833333333333333}*cell[3];
auto x83 = V{0.0833333333333333}*cell[12];
auto x84 = V{0.00462962962962963}*x27;
auto x85 = V{0.00925925925925926}*x27;
auto x86 = V{0.00462962962962963}*x27;
auto x87 = V{0.00925925925925926}*x27;
auto x88 = x58*x84;
auto x89 = x72*x86;
auto x90 = V{0.00231481481481482}*x27;
auto x91 = x39*x85 - x51*x90 + x64*x90 + x68*x90 + x69*x90 - V{0.166666666666667}*cell[11] + V{0.0833333333333334}*cell[15] + V{0.0833333333333334}*cell[16] + V{0.0833333333333334}*cell[6] + V{0.0833333333333334}*cell[7] + V{6.93889390390723e-18};
auto x92 = x23*(-x53*x87 + x54*x84 + x56*x87 + x75*x85 + x79*x86 - x81*x85 - x82 - x83 - x88 - x89 + x91 + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[13] - V{0.333333333333333}*cell[17] - V{0.333333333333333}*cell[18] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[5]) + V{0.0555555555555556};
auto x93 = V{0.0833333333333333}*cell[1];
auto x94 = V{0.0833333333333333}*cell[10];
auto x95 = x56*x84;
auto x96 = x75*x86;
auto x97 = x23*(V{0.00462962962962963}*x24*x26*x51 + V{0.00462962962962963}*x24*x26*x53 + V{0.00462962962962963}*x24*x26*x54 + V{0.00462962962962963}*x24*x26*x79 + V{0.00462962962962963}*x24*x26*x81 - V{0.0185185185185185}*x27*x39 - x64*x84 - x68*x84 - x69*x84 - x82 - x83 - x88 - x89 - x93 - x94 - x95 - x96 + V{0.333333333333333}*cell[11] + V{0.166666666666667}*cell[13] - V{0.166666666666667}*cell[15] - V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[5] - V{0.166666666666667}*cell[6] - V{0.166666666666667}*cell[7] + V{6.93889390390723e-18}) + V{0.0555555555555556};
auto x98 = x23*(x53*x84 - x54*x87 + x58*x87 + x72*x85 - x79*x85 + x81*x86 + x91 - x93 - x94 - x95 - x96 + V{0.166666666666667}*cell[12] - V{0.333333333333333}*cell[13] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[3] - V{0.333333333333333}*cell[5]) + V{0.0555555555555556};
auto x99 = V{0.0231481481481481}*x27;
auto x100 = V{0.00462962962962963}*x27;
auto x101 = V{0.00231481481481481}*x27;
auto x102 = V{0.00462962962962963}*x27;
auto x103 = -x102*x53 + x102*x56 - x75*x90 + x81*x90 + V{0.0833333333333333}*cell[10] + V{0.0833333333333334}*cell[17] + V{0.0833333333333334}*cell[18] + V{0.0833333333333333}*cell[1] + V{0.0416666666666667};
auto x104 = V{0.00115740740740741}*x27;
auto x105 = -x104*x51 + x104*x64 + x104*x68 + x104*x69 - x39*x87 + V{0.166666666666667}*cell[11] + V{0.0416666666666667}*cell[15] + V{0.0416666666666667}*cell[16] + V{0.0416666666666667}*cell[6] + V{0.0416666666666667}*cell[7];
auto x106 = x101*x54 - x101*x58 + x103 + x105 - V{0.0416666666666667}*cell[12] - V{0.0416666666666667}*cell[3];
auto x107 = x23*(-x100*x79 + x106 - x72*x99 + V{0.833333333333333}*cell[13] - V{0.166666666666667}*cell[5]) + V{0.0277777777777778};
auto x108 = x23*(x100*x72 + x106 + x79*x99 - V{0.166666666666667}*cell[13] + V{0.833333333333333}*cell[5]) + V{0.0277777777777778};
auto x109 = V{0.0115740740740741}*x27;
auto x110 = V{0.00231481481481481}*x27;
auto x111 = -x102*x54 + x102*x58 - x72*x90 + x79*x90 + V{0.0833333333333333}*cell[12] + V{0.0833333333333334}*cell[13] + V{0.0833333333333333}*cell[3] + V{0.0833333333333334}*cell[5];
auto x112 = x103 + x111 + x39*x84 - V{0.0833333333333333}*cell[11];
auto x113 = x23*(-x109*x51 + x109*x69 - x110*x64 - x110*x68 + x112 + V{0.416666666666667}*cell[15] - V{0.0833333333333333}*cell[16] + V{0.416666666666667}*cell[6] - V{0.0833333333333333}*cell[7]) + V{0.0277777777777778};
auto x114 = x23*(x109*x64 + x109*x68 + x110*x51 - x110*x69 + x112 - V{0.0833333333333333}*cell[15] + V{0.416666666666667}*cell[16] - V{0.0833333333333333}*cell[6] + V{0.416666666666667}*cell[7]) + V{0.0277777777777778};
auto x115 = x101*x53 - x101*x56 + x105 + x111 - V{0.0416666666666667}*cell[10] - V{0.0416666666666667}*cell[1] + V{0.0416666666666667};
auto x116 = x23*(-x100*x81 + x115 - x75*x99 + V{0.833333333333333}*cell[17] - V{0.166666666666667}*cell[18]) + V{0.0277777777777778};
auto x117 = -x80;
auto x118 = x37 + x62;
auto x119 = x23*(x100*x75 + x115 + x81*x99 - V{0.166666666666667}*cell[17] + V{0.833333333333333}*cell[18]) + V{0.0277777777777778};
auto x0 = x23*(x25 - x28*x72 - x28*x75 + x28*x79 + x28*x81 + x40 - x41*x53 - x41*x54 + x41*x56 + x41*x58 + x41*x64 + x41*x68 + x41*x69 + x52 + V{0.5}*cell[10] + V{1}*cell[11] + V{0.5}*cell[12] + V{1}*cell[15] + V{1}*cell[16] + V{0.5}*cell[1] + V{0.5}*cell[3] + V{1}*cell[6] + V{1}*cell[7] + V{0.5}) - V{0.333333333333333}*x27*x62 + V{-0.333333333333333};
auto x1 = -x28*x56 - x92;
auto x2 = -x28*(x30 - x33 + x37 + x57) - x97;
auto x3 = -x28*x58 - x98;
auto x4 = -x107 - x41*(x37 + x67 - x71);
auto x5 = -x108 - x41*x79;
auto x6 = -x113 - x41*x69;
auto x7 = -x114 - x41*x68;
auto x8 = -x116 - x41*(x37 + x63 - x74);
auto x9 = -x119 - x41*(x118 + x65 - V{4.5}*x117*x117);
auto x10 = V{0.0555555555555556}*x24*x26*x53 - x92;
auto x11 = -x40 - x97;
auto x12 = V{0.0555555555555556}*x24*x26*x54 - x98;
auto x13 = -x107 + V{0.0277777777777778}*x24*x26*x72;
auto x14 = -x108 - x41*(x118 + x59 - V{4.5}*x77*x77);
auto x15 = -x113 - x52;
auto x16 = -x114 - x41*x64;
auto x17 = -x116 + V{0.0277777777777778}*x24*x26*x75;
auto x18 = -x119 - x41*x81;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { V{1}*x27, x29 + x32 + x34 };
}
 
};
 
template <typename... FIELDS>
struct RLB::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<2,-1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x23 = x22 + V{-1};
auto x24 = V{1} / (x21 + V{-1});
auto x25 = V{2}*cell[16] + V{2}*cell[18] + V{2}*cell[6] + V{2}*cell[8];
auto x26 = x25 + cell[0] + cell[10] + cell[11] + cell[13] + cell[14] + cell[1] + cell[2] + V{2}*cell[3] + cell[4] + cell[5] + V{1};
auto x27 = x24*x26;
auto x28 = V{0.0555555555555556}*x27;
auto x29 = x19*x19;
auto x30 = V{1.5}*x29;
auto x31 = V{3}*x21;
auto x32 = x21*x21;
auto x33 = V{3}*x32;
auto x34 = x20*x20;
auto x35 = V{1.5}*x34;
auto x36 = x35 + V{-1};
auto x37 = x30 + x31 - x33 + x36;
auto x38 = -x28*x37;
auto x39 = V{0.0277777777777778}*x27;
auto x40 = V{3}*x20;
auto x41 = x19 + x20;
auto x42 = V{4.5}*(x41*x41);
auto x43 = V{3}*x19;
auto x44 = V{1.5}*x32;
auto x45 = x30 + x44 + V{-1};
auto x46 = x35 + x45;
auto x47 = x43 + x46;
auto x48 = x40 - x42 + x47;
auto x49 = -x39*x48;
auto x50 = -x40;
auto x51 = x19 - x20;
auto x52 = -x51;
auto x53 = x47 + x50 - V{4.5}*x52*x52;
auto x54 = -x39*x53;
auto x55 = -x35;
auto x56 = V{1} - x44;
auto x57 = x55 + x56;
auto x58 = x43 + x57;
auto x59 = -x30;
auto x60 = x40 + x59;
auto x61 = x42 + x58 + x60;
auto x62 = x39*x61;
auto x63 = -x43;
auto x64 = x40 + x46;
auto x65 = x63 + x64 - V{4.5}*x51*x51;
auto x66 = -x39*x65;
auto x67 = V{3}*x29;
auto x68 = x58 + x67;
auto x69 = V{3}*x34;
auto x70 = x56 + x60 + x69;
auto x71 = x40 + x45 - x69;
auto x72 = x36 + x43 + x44 - x67;
auto x73 = x19 + x21;
auto x74 = V{4.5}*(x73*x73);
auto x75 = x31 + x47 - x74;
auto x76 = x20 + x21;
auto x77 = V{4.5}*(x76*x76);
auto x78 = x31 + x64 - x77;
auto x79 = -x21;
auto x80 = x19 + x79;
auto x81 = x31 + x46;
auto x82 = x63 + x81 - V{4.5}*x80*x80;
auto x83 = x20 + x79;
auto x84 = x50 + x81 - V{4.5}*x83*x83;
auto x85 = V{0.0833333333333333}*cell[2];
auto x86 = V{0.0833333333333333}*cell[11];
auto x87 = V{0.00462962962962963}*x27;
auto x88 = V{0.00925925925925926}*x27;
auto x89 = V{0.00925925925925926}*x27;
auto x90 = x70*x87;
auto x91 = V{0.00462962962962963}*x27;
auto x92 = x75*x91;
auto x93 = x82*x91;
auto x94 = V{0.00231481481481482}*x27;
auto x95 = x37*x88 - x48*x94 - x53*x94 + x61*x94 - x65*x94 + V{0.0833333333333334}*cell[13] + V{0.0833333333333334}*cell[14] - V{0.166666666666667}*cell[3] + V{0.0833333333333334}*cell[4] + V{0.0833333333333334}*cell[5] + V{6.93889390390723e-18};
auto x96 = x23*(x68*x89 + x71*x87 - x72*x89 + x78*x88 + x84*x88 - x85 - x86 - x90 - x92 - x93 + x95 + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[16] - V{0.333333333333333}*cell[18] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[6] - V{0.333333333333333}*cell[8]) + V{0.0555555555555556};
auto x97 = V{0.0833333333333333}*cell[1];
auto x98 = V{0.0833333333333333}*cell[10];
auto x99 = x68*x87;
auto x100 = x78*x91;
auto x101 = x84*x91;
auto x102 = x23*(-x100 - x101 + x70*x89 - x71*x89 + x72*x87 + x75*x88 + x82*x88 + x95 - x97 - x98 - x99 + V{0.166666666666667}*cell[11] - V{0.333333333333333}*cell[16] + V{0.166666666666667}*cell[18] + V{0.166666666666667}*cell[2] - V{0.333333333333333}*cell[6] + V{0.166666666666667}*cell[8]) + V{0.0555555555555556};
auto x103 = x23*(-x100 - x101 + V{0.00462962962962963}*x24*x26*x48 + V{0.00462962962962963}*x24*x26*x53 + V{0.00462962962962963}*x24*x26*x65 + V{0.00462962962962963}*x24*x26*x71 + V{0.00462962962962963}*x24*x26*x72 - V{0.0185185185185185}*x27*x37 - x61*x87 - x85 - x86 - x90 - x92 - x93 - x97 - x98 - x99 - V{0.166666666666667}*cell[13] - V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[16] + V{0.166666666666667}*cell[18] + V{0.333333333333333}*cell[3] - V{0.166666666666667}*cell[4] - V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[6] + V{0.166666666666667}*cell[8] + V{6.93889390390723e-18}) + V{0.0555555555555556};
auto x104 = V{0.0115740740740741}*x27;
auto x105 = V{0.00231481481481481}*x27;
auto x106 = V{0.00462962962962963}*x27;
auto x107 = x106*x68 - x106*x72 - x78*x94 - x84*x94 + V{0.0833333333333333}*cell[10] + V{0.0833333333333334}*cell[18] + V{0.0833333333333333}*cell[1] + V{0.0833333333333334}*cell[8] + V{0.0416666666666667};
auto x108 = x106*x70 - x106*x71 - x75*x94 - x82*x94 + V{0.0833333333333333}*cell[11] + V{0.0833333333333334}*cell[16] + V{0.0833333333333333}*cell[2] + V{0.0833333333333334}*cell[6];
auto x109 = x107 + x108 + x37*x87 - V{0.0833333333333333}*cell[3];
auto x110 = x23*(-x104*x48 + x104*x61 + x105*x53 + x105*x65 + x109 + V{0.416666666666667}*cell[13] - V{0.0833333333333333}*cell[14] + V{0.416666666666667}*cell[4] - V{0.0833333333333333}*cell[5]) + V{0.0277777777777778};
auto x111 = x23*(-x104*x53 - x104*x65 + x105*x48 - x105*x61 + x109 - V{0.0833333333333333}*cell[13] + V{0.416666666666667}*cell[14] - V{0.0833333333333333}*cell[4] + V{0.416666666666667}*cell[5]) + V{0.0277777777777778};
auto x112 = V{0.00462962962962963}*x27;
auto x113 = V{0.0231481481481481}*x27;
auto x114 = V{0.00231481481481481}*x27;
auto x115 = V{0.00115740740740741}*x27;
auto x116 = -x115*x48 - x115*x53 + x115*x61 - x115*x65 - x37*x89 + V{0.0416666666666667}*cell[13] + V{0.0416666666666667}*cell[14] + V{0.166666666666667}*cell[3] + V{0.0416666666666667}*cell[4] + V{0.0416666666666667}*cell[5];
auto x117 = x107 - x114*x70 + x114*x71 + x116 - V{0.0416666666666667}*cell[11] - V{0.0416666666666667}*cell[2];
auto x118 = x23*(x112*x82 - x113*x75 + x117 - V{0.166666666666667}*cell[16] + V{0.833333333333333}*cell[6]) + V{0.0277777777777778};
auto x119 = -x31;
auto x120 = -x80;
auto x121 = x23*(x112*x75 - x113*x82 + x117 + V{0.833333333333333}*cell[16] - V{0.166666666666667}*cell[6]) + V{0.0277777777777778};
auto x122 = x108 - x114*x68 + x114*x72 + x116 - V{0.0416666666666667}*cell[10] - V{0.0416666666666667}*cell[1] + V{0.0416666666666667};
auto x123 = x23*(x112*x84 - x113*x78 + x122 - V{0.166666666666667}*cell[18] + V{0.833333333333333}*cell[8]) + V{0.0277777777777778};
auto x124 = -x83;
auto x125 = x23*(x112*x78 - x113*x84 + x122 + V{0.833333333333333}*cell[18] - V{0.166666666666667}*cell[8]) + V{0.0277777777777778};
auto x126 = x31 + x59;
auto x0 = x23*(x25 - x28*x75 - x28*x78 - x28*x82 - x28*x84 + x38 + x39*x68 + x39*x70 - x39*x71 - x39*x72 + x49 + x54 + x62 + x66 + V{0.5}*cell[10] + V{0.5}*cell[11] + V{1}*cell[13] + V{1}*cell[14] + V{0.5}*cell[1] + V{0.5}*cell[2] + V{1}*cell[3] + V{1}*cell[4] + V{1}*cell[5] + V{0.5}) + V{0.333333333333333}*x27*x46 + V{-0.333333333333333};
auto x1 = V{0.0555555555555556}*x24*x26*x72 - x96;
auto x2 = -x102 + V{0.0555555555555556}*x24*x26*x71;
auto x3 = -x103 - x38;
auto x4 = -x110 - x49;
auto x5 = -x111 - x54;
auto x6 = -x118 + V{0.0277777777777778}*x24*x26*x75;
auto x7 = -x121 + V{0.0277777777777778}*x24*x26*(x119 + x47 - V{4.5}*x120*x120);
auto x8 = -x123 + V{0.0277777777777778}*x24*x26*x78;
auto x9 = -x125 + V{0.0277777777777778}*x24*x26*(x119 + x64 - V{4.5}*x124*x124);
auto x10 = -x28*x68 - x96;
auto x11 = -x102 - x28*x70;
auto x12 = -x103 - x28*(x126 + x33 + x55 + V{1});
auto x13 = -x110 - x62;
auto x14 = -x111 - x66;
auto x15 = -x118 - x39*(x126 + x58 + x74);
auto x16 = -x121 + V{0.0277777777777778}*x24*x26*x82;
auto x17 = -x123 - x39*(x31 + x57 + x60 + x77);
auto x18 = -x125 + V{0.0277777777777778}*x24*x26*x84;
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { -V{1}*x27, x29 + x32 + x34 };
}
 
};
 
template <typename... FIELDS>
struct RLB::type<descriptors::D3Q19<FIELDS...>,momenta::RegularizedVelocityBoundaryTuple<2,1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x23 = x22 + V{-1};
auto x24 = V{1} / (x21 + V{1});
auto x25 = V{2}*cell[15] + V{2}*cell[17] + V{2}*cell[7] + V{2}*cell[9];
auto x26 = x25 + cell[0] + cell[10] + cell[11] + V{2}*cell[12] + cell[13] + cell[14] + cell[1] + cell[2] + cell[4] + cell[5] + V{1};
auto x27 = x24*x26;
auto x28 = V{0.0555555555555556}*x27;
auto x29 = x20*x20;
auto x30 = V{1.5}*x29;
auto x31 = -x30;
auto x32 = x21*x21;
auto x33 = V{3}*x32;
auto x34 = x19*x19;
auto x35 = V{1.5}*x34;
auto x36 = -x35;
auto x37 = V{3}*x21;
auto x38 = x36 + x37;
auto x39 = x31 + x33 + x38 + V{1};
auto x40 = -x28*x39;
auto x41 = V{0.0277777777777778}*x27;
auto x42 = x19 + x20;
auto x43 = x42*x42;
auto x44 = V{3}*x19;
auto x45 = V{1.5}*x32;
auto x46 = V{1} - x45;
auto x47 = x31 + x46;
auto x48 = x44 + x47;
auto x49 = V{3}*x20;
auto x50 = x36 + x49;
auto x51 = V{4.5}*x43 + x48 + x50;
auto x52 = -x41*x51;
auto x53 = V{3}*x34 + x48;
auto x54 = V{3}*x29 + x46 + x50;
auto x55 = x30 + x45 + V{-1};
auto x56 = -V{3}*x34 + x44 + x55;
auto x57 = x35 + V{-1};
auto x58 = -V{3}*x29 + x45 + x49 + x57;
auto x59 = -x44;
auto x60 = x19 - x20;
auto x61 = x35 + x55;
auto x62 = x49 + x61;
auto x63 = x59 + x62 - V{4.5}*x60*x60;
auto x64 = -x49;
auto x65 = -x60;
auto x66 = x44 + x61;
auto x67 = x64 + x66 - V{4.5}*x65*x65;
auto x68 = -V{4.5}*x43 + x44 + x62;
auto x69 = x19 + x21;
auto x70 = V{4.5}*(x69*x69);
auto x71 = x38 + x48 + x70;
auto x72 = x20 + x21;
auto x73 = V{4.5}*(x72*x72);
auto x74 = x37 + x47 + x50 + x73;
auto x75 = -V{3}*x21;
auto x76 = -x21;
auto x77 = x19 + x76;
auto x78 = -x77;
auto x79 = x66 + x75 - V{4.5}*x78*x78;
auto x80 = x20 + x76;
auto x81 = -x80;
auto x82 = x62 + x75 - V{4.5}*x81*x81;
auto x83 = V{0.0833333333333333}*cell[2];
auto x84 = V{0.0833333333333333}*cell[11];
auto x85 = V{0.00462962962962963}*x27;
auto x86 = V{0.00925925925925926}*x27;
auto x87 = V{0.00462962962962963}*x27;
auto x88 = V{0.00925925925925926}*x27;
auto x89 = x58*x85;
auto x90 = x71*x87;
auto x91 = V{0.00231481481481482}*x27;
auto x92 = x39*x86 - x51*x91 + x63*x91 + x67*x91 + x68*x91 - V{0.166666666666667}*cell[12] + V{0.0833333333333334}*cell[13] + V{0.0833333333333334}*cell[14] + V{0.0833333333333334}*cell[4] + V{0.0833333333333334}*cell[5] + V{6.93889390390723e-18};
auto x93 = x23*(-x53*x88 + x54*x85 + x56*x88 + x74*x86 + x79*x87 - x82*x86 - x83 - x84 - x89 - x90 + x92 + V{0.166666666666667}*cell[10] + V{0.166666666666667}*cell[15] - V{0.333333333333333}*cell[17] + V{0.166666666666667}*cell[1] + V{0.166666666666667}*cell[7] - V{0.333333333333333}*cell[9]) + V{0.0555555555555556};
auto x94 = V{0.0833333333333333}*cell[1];
auto x95 = V{0.0833333333333333}*cell[10];
auto x96 = x56*x85;
auto x97 = x74*x87;
auto x98 = x23*(x53*x85 - x54*x88 + x58*x88 + x71*x86 - x79*x86 + x82*x87 + x92 - x94 - x95 - x96 - x97 + V{0.166666666666667}*cell[11] - V{0.333333333333333}*cell[15] + V{0.166666666666667}*cell[17] + V{0.166666666666667}*cell[2] - V{0.333333333333333}*cell[7] + V{0.166666666666667}*cell[9]) + V{0.0555555555555556};
auto x99 = x23*(V{0.00462962962962963}*x24*x26*x51 + V{0.00462962962962963}*x24*x26*x53 + V{0.00462962962962963}*x24*x26*x54 + V{0.00462962962962963}*x24*x26*x79 + V{0.00462962962962963}*x24*x26*x82 - V{0.0185185185185185}*x27*x39 - x63*x85 - x67*x85 - x68*x85 - x83 - x84 - x89 - x90 - x94 - x95 - x96 - x97 + V{0.333333333333333}*cell[12] - V{0.166666666666667}*cell[13] - V{0.166666666666667}*cell[14] + V{0.166666666666667}*cell[15] + V{0.166666666666667}*cell[17] - V{0.166666666666667}*cell[4] - V{0.166666666666667}*cell[5] + V{0.166666666666667}*cell[7] + V{0.166666666666667}*cell[9] + V{6.93889390390723e-18}) + V{0.0555555555555556};
auto x100 = V{0.0115740740740741}*x27;
auto x101 = V{0.00231481481481481}*x27;
auto x102 = V{0.00462962962962963}*x27;
auto x103 = -x102*x53 + x102*x56 - x74*x91 + x82*x91 + V{0.0833333333333333}*cell[10] + V{0.0833333333333334}*cell[17] + V{0.0833333333333333}*cell[1] + V{0.0833333333333334}*cell[9] + V{0.0416666666666667};
auto x104 = -x102*x54 + x102*x58 - x71*x91 + x79*x91 + V{0.0833333333333333}*cell[11] + V{0.0833333333333334}*cell[15] + V{0.0833333333333333}*cell[2] + V{0.0833333333333334}*cell[7];
auto x105 = x103 + x104 + x39*x85 - V{0.0833333333333333}*cell[12];
auto x106 = x23*(-x100*x51 + x100*x68 - x101*x63 - x101*x67 + x105 + V{0.416666666666667}*cell[13] - V{0.0833333333333333}*cell[14] + V{0.416666666666667}*cell[4] - V{0.0833333333333333}*cell[5]) + V{0.0277777777777778};
auto x107 = x23*(x100*x63 + x100*x67 + x101*x51 - x101*x68 + x105 - V{0.0833333333333333}*cell[13] + V{0.416666666666667}*cell[14] - V{0.0833333333333333}*cell[4] + V{0.416666666666667}*cell[5]) + V{0.0277777777777778};
auto x108 = V{0.0231481481481481}*x27;
auto x109 = V{0.00462962962962963}*x27;
auto x110 = V{0.00231481481481481}*x27;
auto x111 = V{0.00115740740740741}*x27;
auto x112 = -x111*x51 + x111*x63 + x111*x67 + x111*x68 - x39*x88 + V{0.166666666666667}*cell[12] + V{0.0416666666666667}*cell[13] + V{0.0416666666666667}*cell[14] + V{0.0416666666666667}*cell[4] + V{0.0416666666666667}*cell[5];
auto x113 = x103 + x110*x54 - x110*x58 + x112 - V{0.0416666666666667}*cell[11] - V{0.0416666666666667}*cell[2];
auto x114 = x23*(-x108*x71 - x109*x79 + x113 + V{0.833333333333333}*cell[15] - V{0.166666666666667}*cell[7]) + V{0.0277777777777778};
auto x115 = x23*(x108*x79 + x109*x71 + x113 - V{0.166666666666667}*cell[15] + V{0.833333333333333}*cell[7]) + V{0.0277777777777778};
auto x116 = x104 + x110*x53 - x110*x56 + x112 - V{0.0416666666666667}*cell[10] - V{0.0416666666666667}*cell[1] + V{0.0416666666666667};
auto x117 = x23*(-x108*x74 - x109*x82 + x116 + V{0.833333333333333}*cell[17] - V{0.166666666666667}*cell[9]) + V{0.0277777777777778};
auto x118 = x23*(x108*x82 + x109*x74 + x116 - V{0.166666666666667}*cell[17] + V{0.833333333333333}*cell[9]) + V{0.0277777777777778};
auto x119 = x37 + x61;
auto x0 = x23*(x25 - x28*x71 - x28*x74 + x28*x79 + x28*x82 + x40 - x41*x53 - x41*x54 + x41*x56 + x41*x58 + x41*x63 + x41*x67 + x41*x68 + x52 + V{0.5}*cell[10] + V{0.5}*cell[11] + V{1}*cell[12] + V{1}*cell[13] + V{1}*cell[14] + V{0.5}*cell[1] + V{0.5}*cell[2] + V{1}*cell[4] + V{1}*cell[5] + V{0.5}) - V{0.333333333333333}*x27*x61 + V{-0.333333333333333};
auto x1 = -x28*x56 - x93;
auto x2 = -x28*x58 - x98;
auto x3 = -x28*(x30 - x33 + x37 + x57) - x99;
auto x4 = -x106 - x41*x68;
auto x5 = -x107 - x41*x67;
auto x6 = -x114 - x41*(x37 + x66 - x70);
auto x7 = -x115 - x41*x79;
auto x8 = -x117 - x41*(x37 + x62 - x73);
auto x9 = -x118 - x41*x82;
auto x10 = V{0.0555555555555556}*x24*x26*x53 - x93;
auto x11 = V{0.0555555555555556}*x24*x26*x54 - x98;
auto x12 = -x40 - x99;
auto x13 = -x106 - x52;
auto x14 = -x107 - x41*x63;
auto x15 = -x114 + V{0.0277777777777778}*x24*x26*x71;
auto x16 = -x115 - x41*(x119 + x59 - V{4.5}*x77*x77);
auto x17 = -x117 + V{0.0277777777777778}*x24*x26*x74;
auto x18 = -x118 - x41*(x119 + x64 - V{4.5}*x80*x80);
cell[0] = x0;
cell[1] = x1;
cell[2] = x2;
cell[3] = x3;
cell[4] = x4;
cell[5] = x5;
cell[6] = x6;
cell[7] = x7;
cell[8] = x8;
cell[9] = x9;
cell[10] = x10;
cell[11] = x11;
cell[12] = x12;
cell[13] = x13;
cell[14] = x14;
cell[15] = x15;
cell[16] = x16;
cell[17] = x17;
cell[18] = x18;
return { V{1}*x27, x29 + x32 + x34 };
}
 
};
 
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D3Q19<FIELDS...>,momenta::BasicDirichletVelocityBoundaryTuple<0,-1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x23 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x24 = x22 + V{-1};
auto x25 = x19 + V{-1};
auto x26 = V{1} / (x25);
auto x27 = V{2}*cell[1] + V{2}*cell[4] + V{2}*cell[5] + V{2}*cell[6] + V{2}*cell[7] + V{1};
auto x28 = x27 + cell[0] + cell[11] + cell[12] + cell[17] + cell[18] + cell[2] + cell[3] + cell[8] + cell[9];
auto x29 = x26*x28;
auto x30 = x19*x19;
auto x31 = V{1.5}*x30;
auto x32 = x20*x20;
auto x33 = V{1.5}*x32;
auto x34 = x21*x21;
auto x35 = V{1.5}*x34;
auto x36 = x33 + x35 + V{-1};
auto x37 = x31 + x36;
auto x38 = x23 + V{-1};
auto x39 = x25*x38/x28 + V{1};
auto x40 = V{0.0555555555555556}*x29;
auto x41 = V{3}*x19;
auto x42 = V{3}*x30;
auto x43 = x36 + x41 - x42;
auto x44 = V{3}*x20;
auto x45 = V{3}*x32;
auto x46 = x31 + V{-1};
auto x47 = x35 + x44 - x45 + x46;
auto x48 = V{3}*x21;
auto x49 = V{3}*x34;
auto x50 = x33 + x46 + x48 - x49;
auto x51 = V{0.0277777777777778}*x29;
auto x52 = x19 + x20;
auto x53 = V{4.5}*(x52*x52);
auto x54 = x37 + x41;
auto x55 = x44 - x53 + x54;
auto x56 = -x44;
auto x57 = x19 - x20;
auto x58 = -x57;
auto x59 = x54 + x56 - V{4.5}*x58*x58;
auto x60 = x19 + x21;
auto x61 = V{4.5}*(x60*x60);
auto x62 = x48 + x54 - x61;
auto x63 = -x48;
auto x64 = -x21;
auto x65 = x19 + x64;
auto x66 = -x65;
auto x67 = x54 + x63 - V{4.5}*x66*x66;
auto x68 = x20 + x21;
auto x69 = V{4.5}*(x68*x68);
auto x70 = x37 + x44;
auto x71 = x48 - x69 + x70;
auto x72 = x20 + x64;
auto x73 = -x72;
auto x74 = x63 + x70 - V{4.5}*x73*x73;
auto x75 = -x33;
auto x76 = V{1} - x35;
auto x77 = x75 + x76;
auto x78 = x41 + x77;
auto x79 = x42 + x78;
auto x80 = x39*x40;
auto x81 = -x31;
auto x82 = x44 + x81;
auto x83 = x45 + x76 + x82;
auto x84 = x48 + x81;
auto x85 = x49 + x75 + x84 + V{1};
auto x86 = x53 + x78 + x82;
auto x87 = x39*x51;
auto x88 = -x41;
auto x89 = x70 + x88 - V{4.5}*x57*x57;
auto x90 = x61 + x78 + x84;
auto x91 = x37 + x48;
auto x92 = x88 + x91 - V{4.5}*x65*x65;
auto x93 = x48 + x69 + x77 + x82;
auto x94 = x56 + x91 - V{4.5}*x72*x72;
cell[0] = -x24*(-V{0.333333333333333}*x29*x37 + cell[0] + V{0.333333333333333}) + V{0.333333333333333}*x26*x28*x37*x39 + V{-0.333333333333333};
cell[1] = -x24*(-x40*x43 + cell[1] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x43 + V{-0.0555555555555556};
cell[2] = -x24*(-x40*x47 + cell[2] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x47 + V{-0.0555555555555556};
cell[3] = -x24*(-x40*x50 + cell[3] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x50 + V{-0.0555555555555556};
cell[4] = -x24*(-x51*x55 + cell[4] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x55 + V{-0.0277777777777778};
cell[5] = -x24*(-x51*x59 + cell[5] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x59 + V{-0.0277777777777778};
cell[6] = -x24*(-x51*x62 + cell[6] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x62 + V{-0.0277777777777778};
cell[7] = -x24*(-x51*x67 + cell[7] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x67 + V{-0.0277777777777778};
cell[8] = -x24*(-x51*x71 + cell[8] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x71 + V{-0.0277777777777778};
cell[9] = -x24*(-x51*x74 + cell[9] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x74 + V{-0.0277777777777778};
cell[10] = -x24*(x40*x79 + cell[10] + V{0.0555555555555556}) - x79*x80 + V{-0.0555555555555556};
cell[11] = -x24*(x40*x83 + cell[11] + V{0.0555555555555556}) - x80*x83 + V{-0.0555555555555556};
cell[12] = -x24*(x40*x85 + cell[12] + V{0.0555555555555556}) - x80*x85 + V{-0.0555555555555556};
cell[13] = -x24*(x51*x86 + cell[13] + V{0.0277777777777778}) - x86*x87 + V{-0.0277777777777778};
cell[14] = -x24*(-x51*x89 + cell[14] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x89 + V{-0.0277777777777778};
cell[15] = -x24*(x51*x90 + cell[15] + V{0.0277777777777778}) - x87*x90 + V{-0.0277777777777778};
cell[16] = -x24*(-x51*x92 + cell[16] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x92 + V{-0.0277777777777778};
cell[17] = -x24*(x51*x93 + cell[17] + V{0.0277777777777778}) - x87*x93 + V{-0.0277777777777778};
cell[18] = -x24*(-x51*x94 + cell[18] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x94 + V{-0.0277777777777778};
return { -x26*(x27 + V{1}*cell[0] + V{1}*cell[11] + V{1}*cell[12] + V{1}*cell[17] + V{1}*cell[18] + V{1}*cell[2] + V{1}*cell[3] + V{1}*cell[8] + V{1}*cell[9]) - x38, x30 + x32 + x34 };
}
 
};
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D3Q19<FIELDS...>,momenta::BasicDirichletVelocityBoundaryTuple<0,1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x23 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x24 = x22 + V{-1};
auto x25 = x19 + V{1};
auto x26 = V{1} / (x25);
auto x27 = V{2}*cell[10] + V{2}*cell[13] + V{2}*cell[14] + V{2}*cell[15] + V{2}*cell[16] + V{1};
auto x28 = x27 + cell[0] + cell[11] + cell[12] + cell[17] + cell[18] + cell[2] + cell[3] + cell[8] + cell[9];
auto x29 = x26*x28;
auto x30 = V{0.333333333333333}*x29;
auto x31 = x19*x19;
auto x32 = V{1.5}*x31;
auto x33 = x20*x20;
auto x34 = V{1.5}*x33;
auto x35 = x21*x21;
auto x36 = V{1.5}*x35;
auto x37 = x34 + x36 + V{-1};
auto x38 = x32 + x37;
auto x39 = -x25*(x23 + V{-1})/x28 + V{1};
auto x40 = V{0.0555555555555556}*x29;
auto x41 = V{3}*x19;
auto x42 = V{3}*x31;
auto x43 = x37 + x41 - x42;
auto x44 = x39*x40;
auto x45 = V{3}*x20;
auto x46 = V{3}*x33;
auto x47 = x32 + V{-1};
auto x48 = x36 + x45 - x46 + x47;
auto x49 = V{3}*x21;
auto x50 = V{3}*x35;
auto x51 = x34 + x47 + x49 - x50;
auto x52 = V{0.0277777777777778}*x29;
auto x53 = x19 + x20;
auto x54 = V{4.5}*(x53*x53);
auto x55 = x38 + x41;
auto x56 = x45 - x54 + x55;
auto x57 = x39*x52;
auto x58 = -x45;
auto x59 = x19 - x20;
auto x60 = -x59;
auto x61 = x55 + x58 - V{4.5}*x60*x60;
auto x62 = x19 + x21;
auto x63 = V{4.5}*(x62*x62);
auto x64 = x49 + x55 - x63;
auto x65 = -x49;
auto x66 = -x21;
auto x67 = x19 + x66;
auto x68 = -x67;
auto x69 = x55 + x65 - V{4.5}*x68*x68;
auto x70 = x20 + x21;
auto x71 = V{4.5}*(x70*x70);
auto x72 = x38 + x45;
auto x73 = x49 - x71 + x72;
auto x74 = x20 + x66;
auto x75 = -x74;
auto x76 = x65 + x72 - V{4.5}*x75*x75;
auto x77 = -x34;
auto x78 = V{1} - x36;
auto x79 = x77 + x78;
auto x80 = x41 + x79;
auto x81 = x42 + x80;
auto x82 = -x32;
auto x83 = x45 + x82;
auto x84 = x46 + x78 + x83;
auto x85 = x49 + x82;
auto x86 = x50 + x77 + x85 + V{1};
auto x87 = x54 + x80 + x83;
auto x88 = -x41;
auto x89 = x72 + x88 - V{4.5}*x59*x59;
auto x90 = x63 + x80 + x85;
auto x91 = x38 + x49;
auto x92 = x88 + x91 - V{4.5}*x67*x67;
auto x93 = x49 + x71 + x79 + x83;
auto x94 = x58 + x91 - V{4.5}*x74*x74;
cell[0] = -x24*(x30*x38 + cell[0] + V{0.333333333333333}) - x30*x38*x39 + V{-0.333333333333333};
cell[1] = -x24*(x40*x43 + cell[1] + V{0.0555555555555556}) - x43*x44 + V{-0.0555555555555556};
cell[2] = -x24*(x40*x48 + cell[2] + V{0.0555555555555556}) - x44*x48 + V{-0.0555555555555556};
cell[3] = -x24*(x40*x51 + cell[3] + V{0.0555555555555556}) - x44*x51 + V{-0.0555555555555556};
cell[4] = -x24*(x52*x56 + cell[4] + V{0.0277777777777778}) - x56*x57 + V{-0.0277777777777778};
cell[5] = -x24*(x52*x61 + cell[5] + V{0.0277777777777778}) - x57*x61 + V{-0.0277777777777778};
cell[6] = -x24*(x52*x64 + cell[6] + V{0.0277777777777778}) - x57*x64 + V{-0.0277777777777778};
cell[7] = -x24*(x52*x69 + cell[7] + V{0.0277777777777778}) - x57*x69 + V{-0.0277777777777778};
cell[8] = -x24*(x52*x73 + cell[8] + V{0.0277777777777778}) - x57*x73 + V{-0.0277777777777778};
cell[9] = -x24*(x52*x76 + cell[9] + V{0.0277777777777778}) - x57*x76 + V{-0.0277777777777778};
cell[10] = -x24*(-x40*x81 + cell[10] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x81 + V{-0.0555555555555556};
cell[11] = -x24*(-x40*x84 + cell[11] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x84 + V{-0.0555555555555556};
cell[12] = -x24*(-x40*x86 + cell[12] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x86 + V{-0.0555555555555556};
cell[13] = -x24*(-x52*x87 + cell[13] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x87 + V{-0.0277777777777778};
cell[14] = -x24*(x52*x89 + cell[14] + V{0.0277777777777778}) - x57*x89 + V{-0.0277777777777778};
cell[15] = -x24*(-x52*x90 + cell[15] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x90 + V{-0.0277777777777778};
cell[16] = -x24*(x52*x92 + cell[16] + V{0.0277777777777778}) - x57*x92 + V{-0.0277777777777778};
cell[17] = -x24*(-x52*x93 + cell[17] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x93 + V{-0.0277777777777778};
cell[18] = -x24*(x52*x94 + cell[18] + V{0.0277777777777778}) - x57*x94 + V{-0.0277777777777778};
return { -x23 + x26*(x27 + V{1}*cell[0] + V{1}*cell[11] + V{1}*cell[12] + V{1}*cell[17] + V{1}*cell[18] + V{1}*cell[2] + V{1}*cell[3] + V{1}*cell[8] + V{1}*cell[9]) + V{1}, x31 + x33 + x35 };
}
 
};
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D3Q19<FIELDS...>,momenta::BasicDirichletVelocityBoundaryTuple<1,-1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x23 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x24 = x22 + V{-1};
auto x25 = x20 + V{-1};
auto x26 = V{1} / (x25);
auto x27 = V{2}*cell[14] + V{2}*cell[2] + V{2}*cell[4] + V{2}*cell[8] + V{2}*cell[9] + V{1};
auto x28 = x27 + cell[0] + cell[10] + cell[12] + cell[15] + cell[16] + cell[1] + cell[3] + cell[6] + cell[7];
auto x29 = x26*x28;
auto x30 = x19*x19;
auto x31 = V{1.5}*x30;
auto x32 = x20*x20;
auto x33 = V{1.5}*x32;
auto x34 = x21*x21;
auto x35 = V{1.5}*x34;
auto x36 = x33 + x35 + V{-1};
auto x37 = x31 + x36;
auto x38 = x23 + V{-1};
auto x39 = x25*x38/x28 + V{1};
auto x40 = V{0.0555555555555556}*x29;
auto x41 = V{3}*x19;
auto x42 = V{3}*x30;
auto x43 = x36 + x41 - x42;
auto x44 = V{3}*x20;
auto x45 = V{3}*x32;
auto x46 = x31 + V{-1};
auto x47 = x35 + x44 - x45 + x46;
auto x48 = V{3}*x21;
auto x49 = V{3}*x34;
auto x50 = x33 + x46 + x48 - x49;
auto x51 = V{0.0277777777777778}*x29;
auto x52 = x19 + x20;
auto x53 = V{4.5}*(x52*x52);
auto x54 = x37 + x41;
auto x55 = x44 - x53 + x54;
auto x56 = -x44;
auto x57 = x19 - x20;
auto x58 = -x57;
auto x59 = x54 + x56 - V{4.5}*x58*x58;
auto x60 = x19 + x21;
auto x61 = V{4.5}*(x60*x60);
auto x62 = x48 + x54 - x61;
auto x63 = -x48;
auto x64 = -x21;
auto x65 = x19 + x64;
auto x66 = -x65;
auto x67 = x54 + x63 - V{4.5}*x66*x66;
auto x68 = x20 + x21;
auto x69 = V{4.5}*(x68*x68);
auto x70 = x37 + x44;
auto x71 = x48 - x69 + x70;
auto x72 = x20 + x64;
auto x73 = -x72;
auto x74 = x63 + x70 - V{4.5}*x73*x73;
auto x75 = -x33;
auto x76 = V{1} - x35;
auto x77 = x75 + x76;
auto x78 = x41 + x77;
auto x79 = x42 + x78;
auto x80 = x39*x40;
auto x81 = -x31;
auto x82 = x44 + x81;
auto x83 = x45 + x76 + x82;
auto x84 = x48 + x81;
auto x85 = x49 + x75 + x84 + V{1};
auto x86 = x53 + x78 + x82;
auto x87 = x39*x51;
auto x88 = -x41;
auto x89 = x70 + x88 - V{4.5}*x57*x57;
auto x90 = x61 + x78 + x84;
auto x91 = x37 + x48;
auto x92 = x88 + x91 - V{4.5}*x65*x65;
auto x93 = x48 + x69 + x77 + x82;
auto x94 = x56 + x91 - V{4.5}*x72*x72;
cell[0] = -x24*(-V{0.333333333333333}*x29*x37 + cell[0] + V{0.333333333333333}) + V{0.333333333333333}*x26*x28*x37*x39 + V{-0.333333333333333};
cell[1] = -x24*(-x40*x43 + cell[1] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x43 + V{-0.0555555555555556};
cell[2] = -x24*(-x40*x47 + cell[2] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x47 + V{-0.0555555555555556};
cell[3] = -x24*(-x40*x50 + cell[3] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x50 + V{-0.0555555555555556};
cell[4] = -x24*(-x51*x55 + cell[4] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x55 + V{-0.0277777777777778};
cell[5] = -x24*(-x51*x59 + cell[5] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x59 + V{-0.0277777777777778};
cell[6] = -x24*(-x51*x62 + cell[6] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x62 + V{-0.0277777777777778};
cell[7] = -x24*(-x51*x67 + cell[7] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x67 + V{-0.0277777777777778};
cell[8] = -x24*(-x51*x71 + cell[8] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x71 + V{-0.0277777777777778};
cell[9] = -x24*(-x51*x74 + cell[9] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x74 + V{-0.0277777777777778};
cell[10] = -x24*(x40*x79 + cell[10] + V{0.0555555555555556}) - x79*x80 + V{-0.0555555555555556};
cell[11] = -x24*(x40*x83 + cell[11] + V{0.0555555555555556}) - x80*x83 + V{-0.0555555555555556};
cell[12] = -x24*(x40*x85 + cell[12] + V{0.0555555555555556}) - x80*x85 + V{-0.0555555555555556};
cell[13] = -x24*(x51*x86 + cell[13] + V{0.0277777777777778}) - x86*x87 + V{-0.0277777777777778};
cell[14] = -x24*(-x51*x89 + cell[14] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x89 + V{-0.0277777777777778};
cell[15] = -x24*(x51*x90 + cell[15] + V{0.0277777777777778}) - x87*x90 + V{-0.0277777777777778};
cell[16] = -x24*(-x51*x92 + cell[16] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x92 + V{-0.0277777777777778};
cell[17] = -x24*(x51*x93 + cell[17] + V{0.0277777777777778}) - x87*x93 + V{-0.0277777777777778};
cell[18] = -x24*(-x51*x94 + cell[18] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x94 + V{-0.0277777777777778};
return { -x26*(x27 + V{1}*cell[0] + V{1}*cell[10] + V{1}*cell[12] + V{1}*cell[15] + V{1}*cell[16] + V{1}*cell[1] + V{1}*cell[3] + V{1}*cell[6] + V{1}*cell[7]) - x38, x30 + x32 + x34 };
}
 
};
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D3Q19<FIELDS...>,momenta::BasicDirichletVelocityBoundaryTuple<1,1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x23 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x24 = x22 + V{-1};
auto x25 = x20 + V{1};
auto x26 = V{1} / (x25);
auto x27 = V{2}*cell[11] + V{2}*cell[13] + V{2}*cell[17] + V{2}*cell[18] + V{2}*cell[5] + V{1};
auto x28 = x27 + cell[0] + cell[10] + cell[12] + cell[15] + cell[16] + cell[1] + cell[3] + cell[6] + cell[7];
auto x29 = x26*x28;
auto x30 = V{0.333333333333333}*x29;
auto x31 = x19*x19;
auto x32 = V{1.5}*x31;
auto x33 = x20*x20;
auto x34 = V{1.5}*x33;
auto x35 = x21*x21;
auto x36 = V{1.5}*x35;
auto x37 = x34 + x36 + V{-1};
auto x38 = x32 + x37;
auto x39 = -x25*(x23 + V{-1})/x28 + V{1};
auto x40 = V{0.0555555555555556}*x29;
auto x41 = V{3}*x19;
auto x42 = V{3}*x31;
auto x43 = x37 + x41 - x42;
auto x44 = x39*x40;
auto x45 = V{3}*x20;
auto x46 = V{3}*x33;
auto x47 = x32 + V{-1};
auto x48 = x36 + x45 - x46 + x47;
auto x49 = V{3}*x21;
auto x50 = V{3}*x35;
auto x51 = x34 + x47 + x49 - x50;
auto x52 = V{0.0277777777777778}*x29;
auto x53 = x19 + x20;
auto x54 = V{4.5}*(x53*x53);
auto x55 = x38 + x41;
auto x56 = x45 - x54 + x55;
auto x57 = x39*x52;
auto x58 = -x45;
auto x59 = x19 - x20;
auto x60 = -x59;
auto x61 = x55 + x58 - V{4.5}*x60*x60;
auto x62 = x19 + x21;
auto x63 = V{4.5}*(x62*x62);
auto x64 = x49 + x55 - x63;
auto x65 = -x49;
auto x66 = -x21;
auto x67 = x19 + x66;
auto x68 = -x67;
auto x69 = x55 + x65 - V{4.5}*x68*x68;
auto x70 = x20 + x21;
auto x71 = V{4.5}*(x70*x70);
auto x72 = x38 + x45;
auto x73 = x49 - x71 + x72;
auto x74 = x20 + x66;
auto x75 = -x74;
auto x76 = x65 + x72 - V{4.5}*x75*x75;
auto x77 = -x34;
auto x78 = V{1} - x36;
auto x79 = x77 + x78;
auto x80 = x41 + x79;
auto x81 = x42 + x80;
auto x82 = -x32;
auto x83 = x45 + x82;
auto x84 = x46 + x78 + x83;
auto x85 = x49 + x82;
auto x86 = x50 + x77 + x85 + V{1};
auto x87 = x54 + x80 + x83;
auto x88 = -x41;
auto x89 = x72 + x88 - V{4.5}*x59*x59;
auto x90 = x63 + x80 + x85;
auto x91 = x38 + x49;
auto x92 = x88 + x91 - V{4.5}*x67*x67;
auto x93 = x49 + x71 + x79 + x83;
auto x94 = x58 + x91 - V{4.5}*x74*x74;
cell[0] = -x24*(x30*x38 + cell[0] + V{0.333333333333333}) - x30*x38*x39 + V{-0.333333333333333};
cell[1] = -x24*(x40*x43 + cell[1] + V{0.0555555555555556}) - x43*x44 + V{-0.0555555555555556};
cell[2] = -x24*(x40*x48 + cell[2] + V{0.0555555555555556}) - x44*x48 + V{-0.0555555555555556};
cell[3] = -x24*(x40*x51 + cell[3] + V{0.0555555555555556}) - x44*x51 + V{-0.0555555555555556};
cell[4] = -x24*(x52*x56 + cell[4] + V{0.0277777777777778}) - x56*x57 + V{-0.0277777777777778};
cell[5] = -x24*(x52*x61 + cell[5] + V{0.0277777777777778}) - x57*x61 + V{-0.0277777777777778};
cell[6] = -x24*(x52*x64 + cell[6] + V{0.0277777777777778}) - x57*x64 + V{-0.0277777777777778};
cell[7] = -x24*(x52*x69 + cell[7] + V{0.0277777777777778}) - x57*x69 + V{-0.0277777777777778};
cell[8] = -x24*(x52*x73 + cell[8] + V{0.0277777777777778}) - x57*x73 + V{-0.0277777777777778};
cell[9] = -x24*(x52*x76 + cell[9] + V{0.0277777777777778}) - x57*x76 + V{-0.0277777777777778};
cell[10] = -x24*(-x40*x81 + cell[10] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x81 + V{-0.0555555555555556};
cell[11] = -x24*(-x40*x84 + cell[11] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x84 + V{-0.0555555555555556};
cell[12] = -x24*(-x40*x86 + cell[12] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x86 + V{-0.0555555555555556};
cell[13] = -x24*(-x52*x87 + cell[13] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x87 + V{-0.0277777777777778};
cell[14] = -x24*(x52*x89 + cell[14] + V{0.0277777777777778}) - x57*x89 + V{-0.0277777777777778};
cell[15] = -x24*(-x52*x90 + cell[15] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x90 + V{-0.0277777777777778};
cell[16] = -x24*(x52*x92 + cell[16] + V{0.0277777777777778}) - x57*x92 + V{-0.0277777777777778};
cell[17] = -x24*(-x52*x93 + cell[17] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x93 + V{-0.0277777777777778};
cell[18] = -x24*(x52*x94 + cell[18] + V{0.0277777777777778}) - x57*x94 + V{-0.0277777777777778};
return { -x23 + x26*(x27 + V{1}*cell[0] + V{1}*cell[10] + V{1}*cell[12] + V{1}*cell[15] + V{1}*cell[16] + V{1}*cell[1] + V{1}*cell[3] + V{1}*cell[6] + V{1}*cell[7]) + V{1}, x31 + x33 + x35 };
}
 
};
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D3Q19<FIELDS...>,momenta::BasicDirichletVelocityBoundaryTuple<2,-1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x23 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x24 = x22 + V{-1};
auto x25 = x21 + V{-1};
auto x26 = V{1} / (x25);
auto x27 = V{2}*cell[16] + V{2}*cell[18] + V{2}*cell[3] + V{2}*cell[6] + V{2}*cell[8] + V{1};
auto x28 = x27 + cell[0] + cell[10] + cell[11] + cell[13] + cell[14] + cell[1] + cell[2] + cell[4] + cell[5];
auto x29 = x26*x28;
auto x30 = x19*x19;
auto x31 = V{1.5}*x30;
auto x32 = x20*x20;
auto x33 = V{1.5}*x32;
auto x34 = x21*x21;
auto x35 = V{1.5}*x34;
auto x36 = x33 + x35 + V{-1};
auto x37 = x31 + x36;
auto x38 = x23 + V{-1};
auto x39 = x25*x38/x28 + V{1};
auto x40 = V{0.0555555555555556}*x29;
auto x41 = V{3}*x19;
auto x42 = V{3}*x30;
auto x43 = x36 + x41 - x42;
auto x44 = V{3}*x20;
auto x45 = V{3}*x32;
auto x46 = x31 + V{-1};
auto x47 = x35 + x44 - x45 + x46;
auto x48 = V{3}*x21;
auto x49 = V{3}*x34;
auto x50 = x33 + x46 + x48 - x49;
auto x51 = V{0.0277777777777778}*x29;
auto x52 = x19 + x20;
auto x53 = V{4.5}*(x52*x52);
auto x54 = x37 + x41;
auto x55 = x44 - x53 + x54;
auto x56 = -x44;
auto x57 = x19 - x20;
auto x58 = -x57;
auto x59 = x54 + x56 - V{4.5}*x58*x58;
auto x60 = x19 + x21;
auto x61 = V{4.5}*(x60*x60);
auto x62 = x48 + x54 - x61;
auto x63 = -x48;
auto x64 = -x21;
auto x65 = x19 + x64;
auto x66 = -x65;
auto x67 = x54 + x63 - V{4.5}*x66*x66;
auto x68 = x20 + x21;
auto x69 = V{4.5}*(x68*x68);
auto x70 = x37 + x44;
auto x71 = x48 - x69 + x70;
auto x72 = x20 + x64;
auto x73 = -x72;
auto x74 = x63 + x70 - V{4.5}*x73*x73;
auto x75 = -x33;
auto x76 = V{1} - x35;
auto x77 = x75 + x76;
auto x78 = x41 + x77;
auto x79 = x42 + x78;
auto x80 = x39*x40;
auto x81 = -x31;
auto x82 = x44 + x81;
auto x83 = x45 + x76 + x82;
auto x84 = x48 + x81;
auto x85 = x49 + x75 + x84 + V{1};
auto x86 = x53 + x78 + x82;
auto x87 = x39*x51;
auto x88 = -x41;
auto x89 = x70 + x88 - V{4.5}*x57*x57;
auto x90 = x61 + x78 + x84;
auto x91 = x37 + x48;
auto x92 = x88 + x91 - V{4.5}*x65*x65;
auto x93 = x48 + x69 + x77 + x82;
auto x94 = x56 + x91 - V{4.5}*x72*x72;
cell[0] = -x24*(-V{0.333333333333333}*x29*x37 + cell[0] + V{0.333333333333333}) + V{0.333333333333333}*x26*x28*x37*x39 + V{-0.333333333333333};
cell[1] = -x24*(-x40*x43 + cell[1] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x43 + V{-0.0555555555555556};
cell[2] = -x24*(-x40*x47 + cell[2] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x47 + V{-0.0555555555555556};
cell[3] = -x24*(-x40*x50 + cell[3] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x50 + V{-0.0555555555555556};
cell[4] = -x24*(-x51*x55 + cell[4] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x55 + V{-0.0277777777777778};
cell[5] = -x24*(-x51*x59 + cell[5] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x59 + V{-0.0277777777777778};
cell[6] = -x24*(-x51*x62 + cell[6] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x62 + V{-0.0277777777777778};
cell[7] = -x24*(-x51*x67 + cell[7] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x67 + V{-0.0277777777777778};
cell[8] = -x24*(-x51*x71 + cell[8] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x71 + V{-0.0277777777777778};
cell[9] = -x24*(-x51*x74 + cell[9] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x74 + V{-0.0277777777777778};
cell[10] = -x24*(x40*x79 + cell[10] + V{0.0555555555555556}) - x79*x80 + V{-0.0555555555555556};
cell[11] = -x24*(x40*x83 + cell[11] + V{0.0555555555555556}) - x80*x83 + V{-0.0555555555555556};
cell[12] = -x24*(x40*x85 + cell[12] + V{0.0555555555555556}) - x80*x85 + V{-0.0555555555555556};
cell[13] = -x24*(x51*x86 + cell[13] + V{0.0277777777777778}) - x86*x87 + V{-0.0277777777777778};
cell[14] = -x24*(-x51*x89 + cell[14] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x89 + V{-0.0277777777777778};
cell[15] = -x24*(x51*x90 + cell[15] + V{0.0277777777777778}) - x87*x90 + V{-0.0277777777777778};
cell[16] = -x24*(-x51*x92 + cell[16] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x92 + V{-0.0277777777777778};
cell[17] = -x24*(x51*x93 + cell[17] + V{0.0277777777777778}) - x87*x93 + V{-0.0277777777777778};
cell[18] = -x24*(-x51*x94 + cell[18] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x94 + V{-0.0277777777777778};
return { -x26*(x27 + V{1}*cell[0] + V{1}*cell[10] + V{1}*cell[11] + V{1}*cell[13] + V{1}*cell[14] + V{1}*cell[1] + V{1}*cell[2] + V{1}*cell[4] + V{1}*cell[5]) - x38, x30 + x32 + x34 };
}
 
};
 
template <typename... FIELDS>
struct ConstRhoBGK::type<descriptors::D3Q19<FIELDS...>,momenta::BasicDirichletVelocityBoundaryTuple<2,1>,equilibria::SecondOrder> {
 
template <CONCEPT(MinimalCell) CELL, typename PARAMETERS, typename V=typename CELL::value_t>
CellStatistic<V> apply(CELL& cell, PARAMETERS& parameters) any_platform
{
auto x22 = parameters.template get<olb::descriptors::OMEGA>();
auto x20 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(1);
auto x21 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(2);
auto x23 = parameters.template get<olb::statistics::AVERAGE_RHO>();
auto x19 = cell.template getFieldComponent<olb::momenta::FixedVelocityMomentumGeneric::VELOCITY>(0);
auto x24 = x22 + V{-1};
auto x25 = x21 + V{1};
auto x26 = V{1} / (x25);
auto x27 = V{2}*cell[12] + V{2}*cell[15] + V{2}*cell[17] + V{2}*cell[7] + V{2}*cell[9] + V{1};
auto x28 = x27 + cell[0] + cell[10] + cell[11] + cell[13] + cell[14] + cell[1] + cell[2] + cell[4] + cell[5];
auto x29 = x26*x28;
auto x30 = V{0.333333333333333}*x29;
auto x31 = x19*x19;
auto x32 = V{1.5}*x31;
auto x33 = x20*x20;
auto x34 = V{1.5}*x33;
auto x35 = x21*x21;
auto x36 = V{1.5}*x35;
auto x37 = x34 + x36 + V{-1};
auto x38 = x32 + x37;
auto x39 = -x25*(x23 + V{-1})/x28 + V{1};
auto x40 = V{0.0555555555555556}*x29;
auto x41 = V{3}*x19;
auto x42 = V{3}*x31;
auto x43 = x37 + x41 - x42;
auto x44 = x39*x40;
auto x45 = V{3}*x20;
auto x46 = V{3}*x33;
auto x47 = x32 + V{-1};
auto x48 = x36 + x45 - x46 + x47;
auto x49 = V{3}*x21;
auto x50 = V{3}*x35;
auto x51 = x34 + x47 + x49 - x50;
auto x52 = V{0.0277777777777778}*x29;
auto x53 = x19 + x20;
auto x54 = V{4.5}*(x53*x53);
auto x55 = x38 + x41;
auto x56 = x45 - x54 + x55;
auto x57 = x39*x52;
auto x58 = -x45;
auto x59 = x19 - x20;
auto x60 = -x59;
auto x61 = x55 + x58 - V{4.5}*x60*x60;
auto x62 = x19 + x21;
auto x63 = V{4.5}*(x62*x62);
auto x64 = x49 + x55 - x63;
auto x65 = -x49;
auto x66 = -x21;
auto x67 = x19 + x66;
auto x68 = -x67;
auto x69 = x55 + x65 - V{4.5}*x68*x68;
auto x70 = x20 + x21;
auto x71 = V{4.5}*(x70*x70);
auto x72 = x38 + x45;
auto x73 = x49 - x71 + x72;
auto x74 = x20 + x66;
auto x75 = -x74;
auto x76 = x65 + x72 - V{4.5}*x75*x75;
auto x77 = -x34;
auto x78 = V{1} - x36;
auto x79 = x77 + x78;
auto x80 = x41 + x79;
auto x81 = x42 + x80;
auto x82 = -x32;
auto x83 = x45 + x82;
auto x84 = x46 + x78 + x83;
auto x85 = x49 + x82;
auto x86 = x50 + x77 + x85 + V{1};
auto x87 = x54 + x80 + x83;
auto x88 = -x41;
auto x89 = x72 + x88 - V{4.5}*x59*x59;
auto x90 = x63 + x80 + x85;
auto x91 = x38 + x49;
auto x92 = x88 + x91 - V{4.5}*x67*x67;
auto x93 = x49 + x71 + x79 + x83;
auto x94 = x58 + x91 - V{4.5}*x74*x74;
cell[0] = -x24*(x30*x38 + cell[0] + V{0.333333333333333}) - x30*x38*x39 + V{-0.333333333333333};
cell[1] = -x24*(x40*x43 + cell[1] + V{0.0555555555555556}) - x43*x44 + V{-0.0555555555555556};
cell[2] = -x24*(x40*x48 + cell[2] + V{0.0555555555555556}) - x44*x48 + V{-0.0555555555555556};
cell[3] = -x24*(x40*x51 + cell[3] + V{0.0555555555555556}) - x44*x51 + V{-0.0555555555555556};
cell[4] = -x24*(x52*x56 + cell[4] + V{0.0277777777777778}) - x56*x57 + V{-0.0277777777777778};
cell[5] = -x24*(x52*x61 + cell[5] + V{0.0277777777777778}) - x57*x61 + V{-0.0277777777777778};
cell[6] = -x24*(x52*x64 + cell[6] + V{0.0277777777777778}) - x57*x64 + V{-0.0277777777777778};
cell[7] = -x24*(x52*x69 + cell[7] + V{0.0277777777777778}) - x57*x69 + V{-0.0277777777777778};
cell[8] = -x24*(x52*x73 + cell[8] + V{0.0277777777777778}) - x57*x73 + V{-0.0277777777777778};
cell[9] = -x24*(x52*x76 + cell[9] + V{0.0277777777777778}) - x57*x76 + V{-0.0277777777777778};
cell[10] = -x24*(-x40*x81 + cell[10] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x81 + V{-0.0555555555555556};
cell[11] = -x24*(-x40*x84 + cell[11] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x84 + V{-0.0555555555555556};
cell[12] = -x24*(-x40*x86 + cell[12] + V{0.0555555555555556}) + V{0.0555555555555556}*x26*x28*x39*x86 + V{-0.0555555555555556};
cell[13] = -x24*(-x52*x87 + cell[13] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x87 + V{-0.0277777777777778};
cell[14] = -x24*(x52*x89 + cell[14] + V{0.0277777777777778}) - x57*x89 + V{-0.0277777777777778};
cell[15] = -x24*(-x52*x90 + cell[15] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x90 + V{-0.0277777777777778};
cell[16] = -x24*(x52*x92 + cell[16] + V{0.0277777777777778}) - x57*x92 + V{-0.0277777777777778};
cell[17] = -x24*(-x52*x93 + cell[17] + V{0.0277777777777778}) + V{0.0277777777777778}*x26*x28*x39*x93 + V{-0.0277777777777778};
cell[18] = -x24*(x52*x94 + cell[18] + V{0.0277777777777778}) - x57*x94 + V{-0.0277777777777778};
return { -x23 + x26*(x27 + V{1}*cell[0] + V{1}*cell[10] + V{1}*cell[11] + V{1}*cell[13] + V{1}*cell[14] + V{1}*cell[1] + V{1}*cell[2] + V{1}*cell[4] + V{1}*cell[5]) + V{1}, x31 + x33 + x35 };
}
 
};
 
 
 
 
}
 
}
 
#endif
 
#endif