repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
RNG65536/MCRT
|
src/examples/vcm/vcm_misc.h
|
// Disclaimer: This demo is adapted from smallvcm http://www.smallvcm.com/
#pragma once
#include "film.h"
class EyeLight
{
public:
uint32_t m_maxPathLength;
uint32_t m_minPathLength;
uint32_t m_iterations;
FrameBuffer m_framebuffer;
const Scene_debug& m_scene;
public:
EyeLight(const Scene_debug& _scene) : m_scene(_scene)
{
m_minPathLength = 0;
m_maxPathLength = 10;
m_iterations = 0;
m_framebuffer.resize(m_scene.m_camera->filmWidth(), m_scene.m_camera->filmHeight());
}
// final output of this rendering work thread
void GetFramebuffer(FrameBuffer& framebuffer_)
{
framebuffer_ = m_framebuffer;
if (m_iterations > 0)
{
framebuffer_.scale(1.0f / m_iterations);
}
}
virtual void RunIteration(int _iteration)
{
const int resX = int(m_scene.m_camera->filmWidth());
const int resY = int(m_scene.m_camera->filmHeight());
for (int pixID = 0; pixID < resX * resY; pixID++)
{
//////////////////////////////////////////////////////////////////////////
// Generate ray
const int x = pixID % resX;
const int y = pixID / resX;
const vec2 sample = (vec2(float(x), float(y), 0) + vec2(randf(), randf(), 0)) / vec3(float(resX), float(resY), 1);
Ray ray = m_scene.m_camera->makeRay(sample.x, sample.y);
HitInfo_debug hit = m_scene.intersect(ray);
if (hit)
{
float dotLN = dot(hit.shadingNormal(), -ray.dir);
if (dotLN > 0)
{
m_framebuffer.accumulatePixel(x, y, vec3(dotLN));
}
else
{
m_framebuffer.accumulatePixel(x, y, vec3(-dotLN, 0, 0));
}
}
}
m_iterations++;
}
};
class PathTracer
{
public:
uint32_t m_maxPathLength;
uint32_t m_minPathLength;
uint32_t m_iterations;
FrameBuffer m_framebuffer;
const Scene_debug& m_scene;
private:
// Mis power (1 for balance heuristic)
float Mis(float _pdf) const
{
return _pdf;
}
// Mis weight for 2 pdfs
float Mis2(
float _samplePdf,
float _otherPdf) const
{
return Mis(_samplePdf) / (Mis(_samplePdf) + Mis(_otherPdf));
}
public:
PathTracer(const Scene_debug& _scene) : m_scene(_scene)
{
m_minPathLength = 0;
m_maxPathLength = 10; // 2;
m_iterations = 0;
m_framebuffer.resize(m_scene.m_camera->filmWidth(), m_scene.m_camera->filmHeight());
}
// final output of this rendering work thread
void GetFramebuffer(FrameBuffer& framebuffer_)
{
framebuffer_ = m_framebuffer;
if (m_iterations > 0)
{
framebuffer_.scale(1.0f / m_iterations);
}
}
void RunIteration(int _iteration)
{
// We sample lights uniformly
const int lightCount = m_scene.GetLightCount();
const float lightPickProb = 1.0f / lightCount;
const int resX = int(m_scene.m_camera->filmWidth());
const int resY = int(m_scene.m_camera->filmHeight());
for (int pixID = 0; pixID < resX * resY; pixID++)
{
const int x = pixID % resX;
const int y = pixID / resX;
const vec2 sample = (vec2(float(x), float(y), 0) + vec2(randf(), randf(), 0)) / vec3(float(resX), float(resY), 1);
Ray ray = m_scene.m_camera->makeRay(sample.x, sample.y);
vec3 pathWeight(1.0f); // throughput
vec3 color(0.0f);
uint32_t pathLength = 1;
bool lastSpecular = true;
float lastPdfW = 1;
for (;; ++pathLength)
{
#pragma region
HitInfo_debug hit = m_scene.intersect(ray);
if (!hit)
{
if (pathLength < m_minPathLength)
{
break;
}
const BackgroundLight* background = m_scene.GetBackground();
if (!background)
{
break;
}
// For background we cheat with the A/W suffixes,
// and GetRadiance actually returns W instead of A
float directPdfW;
vec3 contrib = background->GetRadiance(m_scene.m_sceneSphere,
ray.dir, vec3(0), &directPdfW);
if (isZero(contrib))
{
break;
}
float misWeight = 1.0f;
if (pathLength > 1 && !lastSpecular)
{
misWeight = Mis2(lastPdfW, directPdfW * lightPickProb);
}
color += pathWeight * misWeight * contrib;
break;
}
#pragma endregion background
vec3 hitPoint = ray.at(hit.distance());
const Material_debug& mat = m_scene.m_materials[hit.materialID()];
vec3 nhit = hit.shadingNormal();
// if (dot(ray.d, nhit) > 0)
// {
// nhit = -nhit;
// }
BSDF<false> bsdf(ray, nhit, &mat);
bool isDelta = bsdf.IsDelta();
if (!bsdf.IsValid())
{
break;
}
#pragma region
int light_id = m_scene.toLightID(hit.materialID());
// directly hit some light, lights do not reflect
if (light_id >= 0)
{
if (pathLength < m_minPathLength)
{
break;
}
const AbstractLight *light = m_scene.GetLightPtr(light_id);
float directPdfA;
vec3 contrib = light->GetRadiance(m_scene.m_sceneSphere,
ray.dir, hitPoint, &directPdfA);
if (isZero(contrib))
{
break;
}
float misWeight = 1.0f;
if (pathLength > 1 && !lastSpecular) // no passive evaluation for primary rays, also no specular
// on last vertex because it's fully accounted for by passive sampling (misWeight = 1)
{
const float directPdfW = pdfAtoW(directPdfA, hit.distance(),
bsdf.CosThetaFix()); // the pdf of having sampled the passive hit direction
// in direct lighting, so using cosine on the light
misWeight = Mis2(lastPdfW, directPdfW * lightPickProb); // multi-sample MIS,
// since NEE on the last vertex has taken care of direct light sampling
}
color += pathWeight * misWeight * contrib;
break;
}
#pragma endregion passive light hit, terminates path
if (pathLength >= m_maxPathLength)
{
break;
}
if (bsdf.ContinuationProb() == 0) // at this point NEE and passive lighting are both evaluated
{
break;
}
#pragma region
// next event estimation
if (!bsdf.IsDelta() && pathLength + 1 >= m_minPathLength) // delta bsdf is accounted for entirely by passive lighting
{
int lightID = int(randf() * lightCount);
const AbstractLight *light = m_scene.GetLightPtr(lightID);
vec3 directionToLight;
float distance, directPdfW;
vec3 radiance = light->Illuminate(m_scene.m_sceneSphere, hitPoint,
vec2(randf(), randf(), 0), directionToLight, distance, directPdfW);
if (!isZero(radiance))
{
float bsdfPdfW, cosThetaOut;
const vec3 factor = bsdf.Evaluate(
directionToLight, cosThetaOut, &bsdfPdfW);
if (!isZero(factor))
{
float weight = 1.0f;
if (!light->IsDelta()) // if light is delta, does not use MIS,
// since there's no chance for passive light hit
{
const float contProb = bsdf.ContinuationProb();
bsdfPdfW *= contProb; // Russian Roulette
weight = Mis2(directPdfW * lightPickProb, bsdfPdfW);
}
vec3 contrib = (weight * cosThetaOut / (lightPickProb * directPdfW)) *
(radiance * factor);
if (!m_scene.Occluded(hitPoint, directionToLight, distance)) // visibility test
{
color += pathWeight * contrib;
}
}
}
}
#pragma endregion direct lighting / next event estimation
#pragma region
// continue random walk
{
vec3 rndTriplet = vec3(randf(), randf(), randf());
float pdf, cosThetaOut;
uint32_t sampledEvent;
vec3 factor = bsdf.Sample(rndTriplet, ray.dir,
pdf, cosThetaOut, &sampledEvent);
if (isZero(factor))
{
break;
}
// Russian roulette
const float contProb = bsdf.ContinuationProb();
lastSpecular = (sampledEvent & BSDF<true>::kSpecular) != 0;
lastPdfW = pdf * contProb;
if (contProb < 1.0f)
{
if (randf() > contProb)
{
break;
}
pdf *= contProb;
}
// pdf == lastPdfW at this point
pathWeight = pathWeight * (factor * (cosThetaOut / pdf));
// We offset ray origin instead of setting tmin due to numeric
// issues in ray-sphere intersection. The isect.dist has to be
// extended by this EPS_RAY after hitpoint is determined
ray.orig = hitPoint + NUM_EPS_RAY * ray.dir;
}
#pragma endregion continue random walk
}
m_framebuffer.accumulatePixel(x, y, color);
}
m_iterations++;
}
};
|
RNG65536/MCRT
|
src/core/acceleration/bvh.h
|
#pragma once
// median split BVH
#include <cassert>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include "aabb.h"
#include "boundedtriangle.h"
#include "constants.h"
#include "intersection.h"
#include "logger.h"
#include "numeric.h"
#include "triangle.h"
struct BVHTriangleReference
{
std::shared_ptr<Triangle> tri;
int id = -1;
};
struct BVHNode
{
std::shared_ptr<AABB> boundingBox;
uint32_t debug_level;
std::string debug_tag;
// TODO : aovid this
virtual bool intersect(Ray& ray, HitInfo& hit_info) const = 0;
};
struct BVHLeafNode : public BVHNode
{
// std::shared_ptr<BoundedTriangle> primitive;
std::shared_ptr<Triangle> primitive;
bool intersect(Ray& ray, HitInfo& hit_info) const override;
};
struct BVHBranchNode : public BVHNode
{
std::shared_ptr<BVHNode> leftChild;
std::shared_ptr<BVHNode> rightChild;
int split_axis;
// TODO : remove redundant logics
bool intersect(Ray& ray, HitInfo& hit_info) const override;
};
struct SplitAxisComparator
{
SplitAxisComparator(int split_axis);
bool operator()(const std::shared_ptr<Triangle>& a,
const std::shared_ptr<Triangle>& b) const;
int m_split_axis;
};
class BVH
{
public:
BVH(const std::vector<Triangle>& mesh);
std::shared_ptr<BVHNode> build(int begin,
int end,
uint32_t level,
const std::string& direction);
bool intersect(Ray& ray, HitInfo& hit_info) const;
private:
// std::vector<std::shared_ptr<BVHTriangleReference> > m_triangles;
std::vector<std::shared_ptr<Triangle> > m_triangles;
std::shared_ptr<BVHNode> m_rootNode;
};
|
RNG65536/MCRT
|
src/core/aabb.h
|
#pragma once
#include "intersection.h"
#include "ray.h"
#include "vectors.h"
class TriangleObject;
class BoundedTriangle;
// axis aligned bounding box
class AABB
{
public:
AABB();
AABB(const float3& min, const float3& max);
AABB(const AABB& aabb);
AABB& operator=(const AABB& aabb);
const float3& min() const;
const float3& max() const;
void reset();
void expandBy(const AABB& box);
void expandBy(const float3& point);
float3 center() const;
float3 diagonal() const;
float surfaceArea() const;
float surfaceAreaCost() const;
bool isValid() const;
int largestDimension() const;
bool intersect(Ray& ray, float& tnear) const;
// MUST use this for AABB culling because
// the ray's origin can be inside the AABB
bool overlap(const Ray& ray) const;
void intersectBy(const AABB& box);
AABB intersect(const AABB& box) const;
AABB clipAxis(float min, float max, int axis) const;
AABB clipX(float min, float max) const;
AABB clipY(float min, float max) const;
AABB clipZ(float min, float max) const;
std::string toString() const;
private:
float3 m_min;
float3 m_max;
};
AABB expandBy(const AABB& a, const AABB& b);
AABB expandBy(const AABB& a, const float3& point);
AABB getAABB(const TriangleObject& object);
|
RNG65536/MCRT
|
src/core/camera.h
|
<reponame>RNG65536/MCRT<gh_stars>1-10
#pragma once
#include "ray.h"
#include "vectors.h"
// pinhole camera model
class Vert;
class Camera
{
public:
Camera(const vec3& origin,
const vec3& lookat,
const vec3& up,
int film_width,
int film_height,
float fov_y);
// map from unit [0, 1]^2 to camera rays
Ray makeRay(float mx, float my) const;
// with perspective correction ??
float measurementFunction(const Vert& current, const Vert& next) const;
float measurementFunction(const Vert& v) const;
float measurementFunction(const vec3& position, const vec3& normal) const;
bool rasterizePrimaryRay(const vec3& direction, float& px, float& py) const;
bool rasterizePoint(const vec3& position, float& px, float& py) const;
int filmWidth() const;
int filmHeight() const;
float filmDistance() const;
vec3 forwardDirection() const;
vec3 position() const;
float filmPdfA() const;
float pixelPdfA() const;
private:
int m_film_width;
int m_film_height;
float m_film_world_width;
float m_film_world_height;
float m_dist;
vec3 m_origin, m_frame_x, m_frame_y, m_forward;
};
|
RNG65536/MCRT
|
src/core/light.h
|
<filename>src/core/light.h<gh_stars>1-10
#ifndef light_h__
#define light_h__
#include "geometry.h"
#include "vectors.h"
class SceneSphere;
// grabbed from smallvcm
// http://www.smallvcm.com/
class AbstractLight
{
public:
/* \brief Illuminates a given point in the scene.
*
* Given a point and two random samples (e.g., for position on area lights),
* this method returns direction from point to light, distance,
* pdf of having chosen this direction (e.g., 1 / area).
* Optionally also returns pdf of emitting particle in this direction,
* and cosine from lights normal (helps with PDF of hitting the light,
* but set to 1 for point lights).
*
* Returns radiance.
*/
virtual vec3 Illuminate(const SceneSphere& _sceneSphere,
const vec3& _receivingPosition,
const vec2& _RndTuple,
vec3& directionToLight_,
float& distance_,
float& directPdfW_,
float* emissionPdfW_ = nullptr,
float* cosAtLight_ = nullptr) const = 0;
/* \brief Emits particle from the light.
*
* Given two sets of random numbers (e.g., position and direction on area
* light), this method generates a position and direction for light
* particle, along with the pdf.
*
* Can also supply pdf (w.r.t. area) of choosing this position when calling
* Illuminate. Also provides cosine on the light (this is 1 for point lights
* etc.).
*
* Returns "energy" that particle carries
*/
virtual vec3 Emit(const SceneSphere& _sceneSphere,
const vec2& _dirRndTuple,
const vec2& _posRndTuple,
vec3& position_,
vec3& direction_,
float& emissionPdfW_,
float* directPdfA_,
float* cosThetaLight_) const = 0;
/* \brief Returns radiance for ray randomly hitting the light
*
* Given ray direction and hitpoint, it returns radiance.
* Can also provide area pdf of sampling hitpoint in Illuminate,
* and of emitting particle along the ray (in opposite direction).
*/
virtual vec3 GetRadiance(const SceneSphere& _sceneSphere,
const vec3& _rayDirection,
const vec3& _hitPoint,
float* directPdfA_ = nullptr,
float* emissionPdfW_ = nullptr) const = 0;
// Whether the light has a finite extent (area, point) or not (directional,
// env. map)
virtual bool IsFinite() const = 0;
// Whether the light has delta function (point, directional) or not (area)
virtual bool IsDelta() const = 0;
};
//////////////////////////////////////////////////////////////////////////
class AreaLight : public AbstractLight
{
public:
vec3 m_p0, m_e1, m_e2;
OrthonormalFrame m_frame;
vec3 m_intensity;
float m_invArea;
public:
AreaLight(const vec3& _p0, const vec3& _p1, const vec3& _p2);
virtual vec3 Illuminate(const SceneSphere& /*aSceneSphere*/,
const vec3& _receivingPosition,
const vec2& _rndTuple,
vec3& directionToLight_,
float& distance_,
float& directPdfW_,
float* emissionPdfW_ = nullptr,
float* cosAtLight_ = nullptr) const;
virtual vec3 Emit(const SceneSphere& /*aSceneSphere*/,
const vec2& _dirRndTuple,
const vec2& _posRndTuple,
vec3& position_,
vec3& direction_,
float& emissionPdfW_,
float* directPdfA_,
float* cosThetaLight_) const;
virtual vec3 GetRadiance(const SceneSphere& /*aSceneSphere*/,
const vec3& _rayDirection,
const vec3& _hitPoint,
float* directPdfA_ = nullptr,
float* emissionPdfW_ = nullptr) const;
// Whether the light has a finite extent (area, point) or not (directional,
// env. map)
virtual bool IsFinite() const;
// Whether the light has delta function (point, directional) or not (area)
virtual bool IsDelta() const;
};
//////////////////////////////////////////////////////////////////////////
class SphericalLight : public AbstractLight
{
public:
SphericalLight(const vec3& _pos, const float _rad);
virtual vec3 Illuminate(const SceneSphere& /*aSceneSphere*/,
const vec3& _receivingPosition,
const vec2& _rndTuple,
vec3& directionToLight_,
float& distance_,
float& directPdfW_,
float* emissionPdfW_ = nullptr,
float* cosAtLight_ = nullptr) const;
virtual vec3 Emit(const SceneSphere& /*aSceneSphere*/,
const vec2& _dirRndTuple,
const vec2& _posRndTuple,
vec3& position_,
vec3& direction_,
float& emissionPdfW_,
float* directPdfA_,
float* cosThetaLight_) const;
virtual vec3 GetRadiance(const SceneSphere& /*aSceneSphere*/,
const vec3& _rayDirection,
const vec3& _hitPoint,
float* directPdfA_ = nullptr,
float* emissionPdfW_ = nullptr) const;
// Whether the light has a finite extent (area, point) or not (directional,
// env. map)
virtual bool IsFinite() const;
// Whether the light has delta function (point, directional) or not (area)
virtual bool IsDelta() const;
public:
vec3 m_pos;
float m_radius;
float m_invArea;
vec3 m_intensity;
};
//////////////////////////////////////////////////////////////////////////
class DirectionalLight : public AbstractLight
{
public:
OrthonormalFrame m_frame;
vec3 m_intensity;
public:
DirectionalLight(const vec3& aDirection);
virtual vec3 Illuminate(const SceneSphere& _sceneSphere,
const vec3& /*aReceivingPosition*/,
const vec2& /*aRndTuple*/,
vec3& directionToLight_,
float& distance_,
float& directPdfW_,
float* emissionPdfW_ = nullptr,
float* cosAtLight_ = nullptr) const;
virtual vec3 Emit(const SceneSphere& _sceneSphere,
const vec2& /*aDirRndTuple*/,
const vec2& _posRndTuple,
vec3& position_,
vec3& direction_,
float& emissionPdfW_,
float* directPdfA_,
float* cosThetaLight_) const;
virtual vec3 GetRadiance(const SceneSphere& /*aSceneSphere*/,
const vec3& /*aRayDirection*/,
const vec3& /*aHitPoint*/,
float* directPdfA_ = nullptr,
float* emissionPdfW_ = nullptr) const;
// Whether the light has a finite extent (area, point) or not (directional,
// env. map)
virtual bool IsFinite() const;
// Whether the light has delta function (point, directional) or not (area)
virtual bool IsDelta() const;
};
//////////////////////////////////////////////////////////////////////////
class PointLight : public AbstractLight
{
public:
vec3 m_position;
vec3 m_intensity;
public:
PointLight(const vec3& _position);
virtual vec3 Illuminate(const SceneSphere& /*aSceneSphere*/,
const vec3& _receivingPosition,
const vec2& _rndTuple,
vec3& directionToLight_,
float& distance_,
float& directPdfW_,
float* emissionPdfW_ = nullptr,
float* cosAtLight_ = nullptr) const;
virtual vec3 Emit(const SceneSphere& /*aSceneSphere*/,
const vec2& _dirRndTuple,
const vec2& /*aPosRndTuple*/,
vec3& position_,
vec3& direction_,
float& emissionPdfW_,
float* directPdfA_,
float* oCosThetaLight) const;
virtual vec3 GetRadiance(const SceneSphere& /*aSceneSphere*/,
const vec3& /*aRayDirection*/,
const vec3& /*aHitPoint*/,
float* directPdfA_ = nullptr,
float* emissionPdfW_ = nullptr) const;
// Whether the light has a finite extent (area, point) or not (directional,
// env. map)
virtual bool IsFinite() const;
// Whether the light has delta function (point, directional) or not (area)
virtual bool IsDelta() const;
};
//////////////////////////////////////////////////////////////////////////
class BackgroundLight : public AbstractLight
{
public:
vec3 m_backgroundColor;
float m_scale;
public:
BackgroundLight();
virtual vec3 Illuminate(const SceneSphere& _sceneSphere,
const vec3& _receivingPosition,
const vec2& _rndTuple,
vec3& directionToLight_,
float& distance_,
float& directPdfW_,
float* emissionPdfW_ = nullptr,
float* cosAtLight_ = nullptr) const;
virtual vec3 Emit(const SceneSphere& _sceneSphere,
const vec2& _dirRndTuple,
const vec2& _posRndTuple,
vec3& position_,
vec3& direction_,
float& emissionPdfW_,
float* directPdfA_,
float* cosThetaLight_) const;
virtual vec3 GetRadiance(const SceneSphere& _sceneSphere,
const vec3& /*aRayDirection*/,
const vec3& /*aHitPoint*/,
float* directPdfA_ = nullptr,
float* emissionPdfW_ = nullptr) const;
// Whether the light has a finite extent (area, point) or not (directional,
// env. map)
virtual bool IsFinite() const;
// Whether the light has delta function (point, directional) or not (area)
virtual bool IsDelta() const;
};
#endif // light_h__
|
RNG65536/MCRT
|
src/core/film.h
|
#pragma once
#include <vector>
#include "vectors.h"
class FrameBuffer
{
public:
FrameBuffer();
FrameBuffer(int w, int h);
~FrameBuffer();
void resize(int w, int h);
void scale(float s);
void accumulatePixel(int i, int j, const vec3& c);
void accumulateBuffer(const FrameBuffer& f);
void tonemapGamma(float gamma);
void tonemapReinhard();
void dumpPPM(const char* filename);
void dumpHDR(const char* filename);
vec3 pixel(int i, int j) const;
int width() const;
int height() const;
private:
std::vector<float> m_buffer;
int m_width, m_height;
int m_total;
};
|
RNG65536/MCRT
|
src/core/envmap.h
|
#pragma once
#include <vector>
// envmap lighting and sampling
struct DirLight
{
float dir[3];
float rad[3]; // pre-multiplied with 1/pdf
float pdf;
};
class DiscreteSampler;
class EnvmapLoader
{
// u for selecting column, v for selecting row
struct EnvmapHeader
{
int width, height; // u for width-wise, v for height-wise
};
std::vector<float> m_buffer; // row-major, top-down storage
EnvmapHeader m_header;
// std::vector<float> m_pdf_u, m_cdf_u; // width-wise [1 * width]
// , P(u) (apriori prob) std::vector<float> m_pdf_uv, m_cdf_uv; //
// height-wise [height * width] , P(v|u) (conditional prob)
// std::vector<DirLight> m_lights; // if full summation is used, then
// pdf for each sample should not be applied ??
// at least the bias is smaller than using dl.pdf at small sampling rates ??
float m_normalizationFactor;
DiscreteSampler* m_sampleU = nullptr;
std::vector<DiscreteSampler*> m_sampleUV;
std::vector<float> m_luminance;
// std::vector<float> m_luminance_warped;
void buildCdf();
void sampleByPdf(float rnd_u,
float rnd_v,
float& u_ref,
float& v_ref) const;
void analyze();
public:
EnvmapLoader();
EnvmapLoader(const std::string filepath);
EnvmapLoader(const std::string filepath, int width, int height);
~EnvmapLoader();
void toPPM(const char* filename);
float getR(int m, int n);
float getG(int m, int n);
float getB(int m, int n);
float getR(int i);
float getG(int i);
float getB(int i);
float sampleRadiance(float dir[3], int channel) const;
void sampleRadiance(float dir[3], float rad[3]) const;
static float luminance(float r, float g, float b);
void scale(float x);
DirLight sample(float r1, float r2) const;
float getPdf(float dir[3]) const;
};
|
RNG65536/MCRT
|
src/core/acceleration/sahbvh.h
|
<gh_stars>1-10
#pragma once
// SAH BVH using binning
#include <cassert>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include "aabb.h"
#include "logger.h"
#include "triangle.h"
#include "constants.h"
#include "numeric.h"
#define DEBUG_BINS 0
#define DEBUG_INFO 0
constexpr int k_leaf_node_size = 4;
constexpr int k_num_binning_buckets = 16; // 256;
constexpr float k_edge_threshold = 1e-3f;
struct SAHBVHNode
{
std::shared_ptr<AABB> bounding_box;
uint32_t debug_level;
std::string debug_tag;
// TOOD : avoid this
virtual bool intersect(Ray& ray, HitInfo& hit_info) const = 0;
};
struct SAHBVHLeafNode : public SAHBVHNode
{
// std::shared_ptr<BoundedTriangle> primitive[k_leaf_node_size];
std::shared_ptr<Triangle> primitive[k_leaf_node_size];
bool intersect(Ray& ray, HitInfo& hit_info) const override;
};
struct SAHBVHBranchNode : public SAHBVHNode
{
std::shared_ptr<SAHBVHNode> left_child;
std::shared_ptr<SAHBVHNode> right_child;
int split_axis;
// TODO : remove redundant logics
bool intersect(Ray& ray, HitInfo& hit_info) const override;
};
struct SAHSplitAxisComparator
{
SAHSplitAxisComparator(int split_axis);
bool operator()(const std::shared_ptr<Triangle>& a,
const std::shared_ptr<Triangle>& b) const;
int m_split_axis;
};
struct MedianSplitter
{
MedianSplitter(std::vector<std::shared_ptr<Triangle> >& triangles,
const AABB& node_bound,
int begin,
int end);
float cost() const;
void sort(int& axis, int& mid);
float m_cost = NUM_INFINITY;
int m_split_axis = -1;
int m_mid = -1;
std::vector<std::shared_ptr<Triangle> >& m_triangles;
const AABB& m_node_bound;
int m_begin;
int m_end;
};
struct SAHBinningBucket
{
AABB m_bounding_box;
int m_num_entries = 0;
int m_is_valid = 0;
};
struct SAHSplitter
{
SAHSplitter(std::vector<std::shared_ptr<Triangle> >& triangles,
const AABB& node_bound,
int begin,
int end);
void sort(int& axis, int& mid);
float m_min_cost;
int m_min_axis; // min cost split axis
int m_min_bin; // min cost split bin, index of the first bucket in the
// second child
std::vector<std::shared_ptr<Triangle> >& m_triangles;
const AABB& m_node_bound;
int m_begin;
int m_end;
float m_edge[3];
};
class SAHBVH
{
public:
SAHBVH(const std::vector<Triangle>& mesh);
std::shared_ptr<SAHBVHNode> buildLeaf(int begin,
int end,
uint32_t level,
const std::string& direction);
std::shared_ptr<SAHBVHBranchNode> buildBranch(int begin,
int end,
uint32_t level,
const std::string& direction,
int& mid);
std::shared_ptr<SAHBVHNode> build(int begin,
int end,
uint32_t level,
const std::string& direction);
bool intersect(Ray& ray, HitInfo& hit_info) const;
private:
std::vector<std::shared_ptr<Triangle> > m_triangles;
std::shared_ptr<SAHBVHNode> m_rootNode;
};
|
RNG65536/MCRT
|
src/core/sample.h
|
#pragma once
#include <random>
#include <stack>
#include <vector>
#include "vectors.h"
class RandomNumberGenerator
{
std::uniform_real_distribution<float> _dist;
std::default_random_engine _rng;
public:
RandomNumberGenerator();
float randf();
};
class DiscreteSampler
{
std::vector<float> m_cdf;
std::vector<float> m_pdf;
public:
DiscreteSampler();
DiscreteSampler(std::vector<float>& data);
void update(std::vector<float>& data);
int sample();
int sample(float r);
float pdf(int idx) const;
};
class Sampler
{
protected:
RandomNumberGenerator _random;
public:
virtual ~Sampler();
virtual float next() = 0;
float randf();
};
class StandardSampler : public Sampler
{
public:
StandardSampler();
float next();
};
struct PrimarySample
{
int modify_time = 0;
float value = 0.0f;
PrimarySample();
PrimarySample(float val);
};
struct PathSample
{
int x, y;
vec3 F;
float weight;
};
class MetropolisSampler : public Sampler
{
float mutate(float x);
int used_rands;
int global_time;
int large_step_time;
bool large_step;
std::vector<PrimarySample> primary_samples;
std::stack<PrimarySample> backup;
public:
MetropolisSampler();
void reset(bool large);
float next();
void accept();
void reject();
};
// return in tangent, bitangent, normal order
vec3 sampleHemisphereCosine(float x, float y);
vec3 sampleHemisphereCosinePower(float g, float x, float y);
vec3 sampleHemisphereUniform(float x, float y, float* pdf = nullptr);
vec3 sampleSphereUniform(float x, float y, float* pdf = nullptr);
vec3 sampleSolidAngleUniform(float x,
float y,
float cos_theta_min,
float* pdf = nullptr);
// sample triangle, returns barycentric coordinates
vec2 sampleTriangleUniform(float x, float y);
/// Sample direction in the upper hemisphere with cosine-proportional pdf
/** The returned PDF is with respect to solid angle measure */
vec3 sampleHemisphereCosineW(float x, float y, float* pdfW = nullptr);
float sampleHemisphereCosinePdfW(const vec3& normal, const vec3& direction);
// Cosine lobe hemisphere sampling
vec3 sampleHemisphereCosinePowerW(float x,
float y,
float power,
float* pdfW = nullptr);
float sampleHemisphereCosinePowerPdfW(const vec3& normal,
const vec3& direction,
float power);
// Disk sampling, map from square to disk
vec2 sampleConcentricDiscA(float x, float y);
float sampleConcentricDiscPdfA();
// Sphere sampling
// vec3 sampleSphereUniformW(float x, float y, float *pdfW);
float sampleSphereUniformPdf();
|
RNG65536/MCRT
|
src/core/consoledebug.h
|
<filename>src/core/consoledebug.h
#pragma once
#include <string>
#include <iostream>
class vec3;
void debugPrint(const vec3& a);
std::string str(const vec3& v);
std::string str(int i);
std::string str(float f);
|
RNG65536/MCRT
|
src/core/numeric.h
|
#pragma once
// utilities
class vec3;
// not thread-safe
float randf();
float randfFast();
float f_min(float a, float b);
float f_max(float a, float b);
int i_min(int a, int b);
int i_max(int a, int b);
float clampf(float x, float a, float b);
// square
float sq(float x);
// compensated summation
struct TKahanAdder
{
double sum, carry, y;
TKahanAdder(const double b = 0.0);
void add(const double b);
};
float toRadians(float deg);
float toDegrees(float rad);
// sRGB luminance
float luminance(const vec3& rgb);
|
RNG65536/MCRT
|
src/examples/photonmap/photonmap.h
|
#ifndef photonmap_h__
#define photonmap_h__
//------------------------------------------------------------------
// photonmap.cpp
// An example implementation of the photon map data structure
//
// <NAME> - February 2001
//------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <malloc.h>
//
// This is the photon
// The power is not compressed so the
// size is 28 bytes
//
typedef struct Photon
{
float pos[3]; // photon position
short plane; // splitting palne for kd-tree
unsigned char theta, phi; // incoming direction
float dir[3];
float power[3]; // photon power (uncompressed)
} Photon;
//
// This structure is used only to locate the
// nearest photons
//
typedef struct NearestPhotons
{
int max;
int found;
int got_heap;
float pos[3];
float *dist2;
const Photon **index;
} NearestPhotons;
//
// This is the Photon_map class
//
class PhotonMap
{
public:
// This is the constructor for the photon map.
// To create the photon map it is necessary to specify the
// maximum number of photons that will be stored
//
PhotonMap(const int max_phot);
~PhotonMap();
// store puts a photon into the flat array that will form
// the final kd-tree
// Call this function to store a photon
//
void store(
const float power[3], // photon power
const float pos[3], // photon position
const float dir[3]); // photon direction
// scale_photon_power is used to scale the power of all
// photons once they have been emitted from the light
// source. scale = 1 / (#emitted photons)
// Call this function after each light source is processed
//
void scale_photon_power(
const float scale); // 1/(number of emitted photons)
// balance creates a left-balanced kd-tree from the flat photon array
// This function should be called before the photon map
// is used for rendering
//
void balance(void); // balance the kd-tree (before use!)
// irradiance_estimate computes an irradiance estimate
// at a given surface position
//
void irradiance_estimate(
float irrad[3], // returned irradiance
const float pos[3], // surface position
const float normal[3], // surface normal at pos
const float max_dist, // max distance to look for photons
const int nphotons) const; // number of photons to use
// locate_photons finds the nearest photons in the
// photon map given the parameters in np
//
void locate_photons(
NearestPhotons *const np, // np is used to locate the photons
const int index) const; // the photons
// photon_dir returns the direction of a photon
//
void photon_dir(
float *dir, // direction of photon (returned)
const Photon *p) const; // the photon
private:
// See "Realistic Image Synthesis using Photon Mapping" Chapter 6
// for an explanation of this function
//
void balance_segment(
Photon **pbal,
Photon **porg,
const int index,
const int start,
const int end);
// median_split spits the photon array into two separate
// pieces around the median, with all photons below
// the median in the lower half and all photons above
// the median in the upper half. The comparison
// criteria is the axis (indicated by the axis parameter)
// (inspired by routine in "Algorithm in C++" by Sedgewick)
//
void median_split(
Photon **p,
const int start,
const int end,
const int median,
const int axis);
Photon *photons;
int stored_photons;
int half_stored_photons;
int max_photons;
int prev_scale;
float costheta[256];
float sintheta[256];
float cosphi[256];
float sinphi[256];
float bbox_min[3]; // use bbox_min
float bbox_max[3]; // use bbox_max
};
#endif // photonmap_h__
|
RNG65536/MCRT
|
src/core/scenebvh.h
|
#pragma once
#include <vector>
#include "intersection.h"
#include "triangle.h"
class Ray;
// scene traversal with acceleration structure
class SceneBVH
{
public:
SceneBVH(const std::vector<TriangleObject>& triangles);
~SceneBVH();
HitInfo intersect(const Ray& ray) const;
bool occluded(const Ray& ray, float tfar) const;
private:
const std::vector<TriangleObject>& m_triangles_ref;
// geometry and acceleration info
void* m_ctx = nullptr;
};
|
RNG65536/MCRT
|
src/core/vectors.h
|
<filename>src/core/vectors.h<gh_stars>1-10
#pragma once
#include <cstdint>
// custom vector and operators
class vec3
{
public:
friend vec3 operator*(float a, const vec3& b);
vec3();
explicit vec3(float a);
vec3(float x, float y, float z);
vec3 operator+(const float& v) const;
vec3 operator+(const vec3& v) const;
vec3 operator-(const float& v) const;
vec3 operator-(const vec3& v) const;
vec3& operator+=(const vec3& v);
vec3& operator-=(const vec3& v);
vec3 operator*(float f) const;
vec3 operator*(const vec3& v) const;
vec3 operator/(const vec3& v) const;
vec3& operator*=(float f);
vec3& operator*=(const vec3& v);
vec3 operator-() const;
vec3 operator/(float f) const;
vec3& operator/=(float f);
const float& operator[](int i) const;
float& operator[](int i);
vec3 normalize() const;
float lengthSquared() const;
float length() const;
bool operator==(const vec3& v) const;
bool operator!=(const vec3& v) const;
bool isNormalized() const;
public:
float x, y, z;
};
typedef vec3 float3;
void debugPrint(const vec3& a);
vec3 operator+(const float a, const vec3& v);
vec3 operator-(const float a, const vec3& v);
vec3 mult(const vec3& v1, const vec3& v2);
vec3 div(const vec3& v1, const vec3& v2);
float dot(const vec3& v1, const vec3& v2);
vec3 cross(const vec3& v1, const vec3& v2);
float length(const vec3& v);
float lengthSquared(const vec3& v);
vec3 normalize(const vec3& v);
vec3 exp(vec3 a);
vec3 sqrt(vec3 a);
vec3 sq(vec3 a);
vec3 f_min(const vec3& a, const vec3& b);
vec3 f_max(const vec3& a, const vec3& b);
float maxComponent(const vec3& v);
float minComponent(const vec3& v);
bool isZero(const vec3& v);
class int3
{
public:
int x, y, z;
int3();
int3(int a, int b, int c);
};
class byte3
{
public:
int8_t x, y, z;
byte3();
byte3(int8_t x, int8_t y, int8_t z);
};
class vec3d
{
public:
double x, y, z;
vec3d();
explicit vec3d(double a);
vec3d(double x, double y, double z);
explicit vec3d(const vec3& v);
vec3 toFloat() const;
vec3d operator+(const vec3d& v) const;
vec3d operator-(const vec3d& v) const;
vec3d operator*(double f) const;
};
double length(const vec3d& v);
vec3d normalize(const vec3d& v);
double dot(const vec3d& v1, const vec3d& v2);
typedef vec3 vec2; // TODO : implement vec2
typedef int3 int2;
|
RNG65536/MCRT
|
src/core/intersection.h
|
<filename>src/core/intersection.h
#pragma once
#include "vectors.h"
// intersection record
class TriangleObject;
class HitInfo
{
public:
HitInfo();
HitInfo(float t,
float u,
float v,
const vec3& nl,
const TriangleObject* hit_object);
operator bool() const;
void reset();
float distance() const;
const vec3& shadingNormal() const;
const vec3& faceNormal() const;
vec3 consistentNormal(const vec3& wi,
vec3* refl = nullptr,
float* cos_wi = nullptr) const;
const TriangleObject* triangleObject() const;
int materialID() const;
void setMaterialID(int id);
int primitiveID() const;
void setPrimitiveID(int id);
bool operator<(const HitInfo& b) const;
public:
float m_t; // ray distance
vec3 m_nl; // shading normal
vec3 m_fn; // face normal
float m_u, m_v; // barycentric coordinates
int m_objID = -1;
int m_matID = -1;
const TriangleObject* m_hit_object = nullptr;
};
|
RNG65536/MCRT
|
src/core/logger.h
|
<gh_stars>1-10
#pragma once
#include <NanoLog.hpp>
#include <iostream>
#include <memory>
#include <sstream>
#include <functional>
// for console output, use std::endl
// for logger output, endl is automatically handled
class Logger
{
public:
static std::ostream& carriage_return(std::ostream& os)
{
os << '\r';
return os;
}
Logger(bool enabled = true,
nanolog::LogLevel log_level = nanolog::LogLevel::INFO);
template <typename T>
Logger& operator<<(const T& t)
{
if (m_enabled)
{
std::cout << t;
if (nanolog::is_logged(m_log_level))
{
(*m_logger) << t;
}
}
return *this;
}
Logger& operator<<(std::ostream& (*f)(std::ostream&))
{
if (m_enabled)
{
f(std::cout);
//if (nanolog::is_logged(m_log_level))
//{
// std::stringstream ss;
// f(ss);
// (*m_logger) << ss.str();
//}
}
return *this;
}
~Logger()
{
if (m_enabled)
{
if (nanolog::is_logged(m_log_level))
{
// finish the line
nanolog::NanoLog() == (*m_logger);
}
}
}
static Logger debug();
static Logger info();
private:
bool m_enabled = true;
std::shared_ptr<nanolog::NanoLogLine> m_logger;
nanolog::LogLevel m_log_level;
};
|
RNG65536/MCRT
|
src/core/material.h
|
#pragma once
#include "vectors.h"
// materials (to be deprecated)
typedef enum { LGHT, DIFF, SPEC, REFR, GLSY, PHNG, VOLM, SSSS } MaterialType;
class AbstractBSDF;
// TODO : integrate bsdf into this class (esp. API)
class Material
{
public:
Material() = default;
Material(const Material& mat);
Material& operator=(const Material& mat);
~Material();
Material(const vec3& c, float e, MaterialType t);
vec3 color() const;
float emission() const;
float ior() const;
float roughness() const;
float glossiness() const;
MaterialType type() const;
bool isLight() const;
vec3 evaluate(const vec3& wi,
const vec3& nl,
const vec3& wo,
float* cos_wo = nullptr,
float* forward_pdfW = nullptr) const;
float pdfW(const vec3& wi, const vec3& nl, const vec3& wo) const;
vec3 sample(const vec3& wi,
const vec3& nl,
float r1,
float r2,
vec3& total_weight,
float* forward_pdfW = nullptr,
float* cos_wo = nullptr,
vec3* bsdf_weight = nullptr) const;
bool isDelta() const;
float getContinuationProbability(const vec3& wi, const vec3& nl) const;
private:
vec3 m_color;
float m_emission; // have no use, todo : deprecate this
float m_ior = 1.33f;
float m_roughness = 1.0f;
float m_glossiness = 25.0f;
MaterialType m_type;
AbstractBSDF* m_bsdf = nullptr;
};
int todo_addMaterial(const Material& mat);
const Material& todo_getMaterial(int mat_id);
|
RNG65536/MCRT
|
src/examples/bdpt/bdpt_impl.h
|
#ifndef bdpt_h__
#define bdpt_h__
#include <vector>
#include "camera.h"
#include "consoledebug.h"
#include "film.h"
#include "geometry.h"
#include "intersection.h"
#include "lightpath.h"
#include "material.h"
#include "numeric.h"
#include "sample.h"
#include "scene.h"
#include "triangle.h"
// reference BDPT implementation based on Hachisuka's MMLT demo
// this implementation is straightforward but less efficient
class ReferenceBDPT
{
const Camera& camera;
FrameBuffer& film;
const Scene& scene;
std::vector<FrameBuffer> pyramid;
private:
// path sampling (recursively construct a path, but the first vertex is
// always constructed outside this function)
void TracePath(Path& path,
const Ray& ray,
const int RayLevel,
const int MaxRayLevel,
PathType path_type,
StandardSampler& sampler)
{
if (RayLevel >= MaxRayLevel)
{
return;
}
HitInfo hit = scene.intersect(ray);
if (!hit)
{
return; // to background
}
vec3 position = ray.at(hit.distance());
vec3 object_normal = hit.shadingNormal();
vec3 orienting_normal =
dot(object_normal, ray.dir) < 0 ? object_normal : -object_normal;
const Vert& last_vertex = path.end();
float total_pdfA = last_vertex.getTotalPdfA();
vec3 throughput = last_vertex.getThroughput();
if (RayLevel == 1 && path_type == PathType::FromEye)
{
total_pdfA *=
camera.measurementFunction(position, orienting_normal);
}
else
{
const vec3& previous_position =
last_vertex.p; // can also use ray.o
float previous_pdfW = last_vertex.pWo;
float pdfA = previous_pdfW *
pdfWtoA(previous_position, position, orienting_normal);
total_pdfA *= pdfA;
float G = geometryTerm(previous_position,
last_vertex.getOrientingNormal(),
position,
orienting_normal);
throughput *= last_vertex.weight * G;
}
const TriangleObject* obj = hit.triangleObject();
const Material& mat = todo_getMaterial(obj->materialID());
const float rnd0 = sampler.next();
const float rnd1 = sampler.next();
vec3 total_weight;
vec3 bsdf_weight;
float pdfW;
float cos_wo;
Ray nr;
nr.orig = position;
// sample a reflected direction according to the scattering material
nr.dir = mat.sample(-ray.dir,
object_normal,
rnd0,
rnd1,
total_weight,
&pdfW,
&cos_wo,
&bsdf_weight);
if (mat.isDelta())
{
bsdf_weight /= cos_wo;
}
// new orientation in case refraction
orienting_normal =
dot(object_normal, nr.dir) > 0 ? object_normal : -object_normal;
// set path data
Vert vert(position, object_normal, obj);
{
vert.pWo = pdfW;
vert.pWi = sqrt(-1); // TODO : use static_NAN
vert.weight = bsdf_weight;
vert.cos_wo = cos_wo;
vert.debug_wi = -ray.dir;
vert.debug_wo = nr.dir;
vert.debug_type = path_type;
vert.setDeltaFlag(mat.isDelta());
vert.setTotalPdfA(total_pdfA);
vert.setOrientingNormal(orienting_normal);
vert.setThroughput(throughput);
vert.debug_vertex_type =
mat.isLight() ? Emitter : (mat.isDelta() ? Specular : Diffuse);
}
path.insert(vert);
// recursive ray tracing for scattering surfaces
// TODO : transform to iterative
if (!mat.isLight())
{
TracePath(path, nr, RayLevel + 1, MaxRayLevel, path_type, sampler);
}
}
Path GenerateEyePath(const int MaxEyeEvents, StandardSampler& sampler)
{
Path Result;
if (MaxEyeEvents == 0)
{
return Result;
}
Ray r = camera.makeRay(sampler.next(), sampler.next());
Vert v(r.orig, camera.forwardDirection(), nullptr);
v.debug_type = FromEye;
v.debug_wo = r.dir;
v.debug_vertex_type = Lens;
v.setDeltaFlag(false);
v.setTotalPdfA(1.0);
v.setOrientingNormal(camera.forwardDirection());
v.setThroughput(vec3(1.0));
v.weight = vec3(1);
v.pWo = 1.0;
Result.insert(v); // first vertex is on the camera aperture (if pinhole
// then it's the camera position)
TracePath(Result, r, 1, MaxEyeEvents, FromEye, sampler);
return Result;
}
Path GenerateLightPath(const int MaxLightEvents, StandardSampler& sampler)
{
Path Result;
if (MaxLightEvents == 0)
{
return Result;
}
const TriangleObject* light_obj = nullptr;
vec3 position, normal, direction;
float pdfA, pdfW;
scene.sampleLightAreaAndDirection(
position, normal, pdfA, direction, pdfW, light_obj, sampler);
assert(nullptr != light_obj);
Vert v(position, normal, light_obj);
v.debug_type = FromLight;
v.debug_wo = direction;
v.debug_vertex_type = Emitter;
v.setDeltaFlag(false);
v.setTotalPdfA(pdfA);
v.setOrientingNormal(normal);
v.setThroughput(todo_getMaterial(light_obj->materialID())
.evaluate(vec3(), normal, direction));
v.weight = vec3(1);
v.pWo = pdfW;
Result.insert(v); // first vertex is on the light's surface
Ray r(position, direction);
TracePath(Result, r, 1, MaxLightEvents, FromLight, sampler);
return Result;
}
// check if the path can be connected or not (visibility term)
// note that there would be false positives if eps is not set,
// and this would lead to fireflies for bsdf may return a zero valued cosine
// term
bool isConnectable(const Path& eye, const Path& light, float& px, float& py)
{
vec3 Direction; // primary ray direction for rasterization
const Vert& ev =
eye.end(); // the last vertex of eye path, to be connected
const Vert& lv =
light.end(); // the last vertex of light path, to be connected
// cannot be connected
if (ev.isDelta() || lv.isDelta())
{
return false;
}
bool be_visible;
// no direct hit to the film (pinhole)
if ((eye.size() == 0) && (light.size() >= 2))
{
be_visible = false;
}
// direct hit to the light source
// ( the only ways to directly render the light are
// Xeye.n == 2 && Xlight.n == 0, and Xeye.n == 1 && Xlight.n == 1 )
else if ((eye.size() >= 2) && (light.size() == 0))
{
be_visible = todo_getMaterial(ev.obj->materialID()).isLight();
// a temporary fix for the fireflies due to s=0 paths that have
// second last vertices too close to the light
// TODO : see if s=0 paths are difficult for BDPT
// be_visible =
// todo_getMaterial(ev.obj->materialID()).isLight() &&
// ev.canConnectTo(eye[eye.size() - 2].p);
Direction = normalize(eye[1].p - eye[0].p);
}
// direct connection to camera
else if ((eye.size() == 1) && (light.size() >= 1))
{
Ray r(eye[0].p, normalize(lv.p - eye[0].p));
be_visible = !scene.occluded(r, length(eye[0].p - lv.p));
Direction = r.dir;
}
// shadow ray connection
else
{
vec3 d = normalize(lv.p - ev.p);
Ray r(ev.p, d);
be_visible = ev.canConnectTo(lv.p) && lv.canConnectTo(ev.p) &&
!scene.occluded(r, length(ev.p - lv.p));
Direction =
normalize(eye[1].p - eye[0].p); // primary ray direction
}
// get the pixel location
return be_visible &&
camera.rasterizePrimaryRay(
Direction, px, py); // the path must be rasterizable
}
// combine two traced paths into all possible subpaths and return pixel
// contributions
/// BPT connections (loop over the path pyramid)
/// - limit the connection to a specific technique if s and t are provided
PathContribution CombinePaths(const Path& EyePath,
const Path& LightPath,
const int SpecifiedNumEyeVertices = -1,
const int SpecifiedNumLightVertices = -1)
{
PathContribution Result;
Result.n = 0;
Result.sc = 0.0;
const bool Specified = (SpecifiedNumEyeVertices != -1) &&
(SpecifiedNumLightVertices != -1);
// MaxEvents = the maximum number of vertices
for (int PathLength = MinPathLength; PathLength <= MaxPathLength;
PathLength++)
{
std::vector<double> debug_weights;
for (int NumEyeVertices = 0; NumEyeVertices <= PathLength + 1;
NumEyeVertices++) // note that num verts = path length + 1
{
const int NumLightVertices = (PathLength + 1) - NumEyeVertices;
if (NumEyeVertices == 0)
continue; // no direct hit to the camera (pinhole camera,
// aperture size = 0)
if (NumEyeVertices > EyePath.size())
continue; // impossible case
if (NumLightVertices > LightPath.size())
continue; // impossible case
// take only the specified technique if provided
if (Specified &&
((SpecifiedNumEyeVertices != NumEyeVertices) ||
(SpecifiedNumLightVertices != NumLightVertices)))
{
continue;
}
// extract subpaths with specific length
Path Eyesubpath = EyePath.subpath(NumEyeVertices);
Path Lightsubpath = LightPath.subpath(NumLightVertices);
// check the path visibility
float px = -1.0,
py = -1.0; // pixel contribution position in pixel units
if (!isConnectable(Eyesubpath, Lightsubpath, px, py))
{
continue;
}
// construct a full path (Eyesubpath + Lightsubpath ->
// SampledPath)
CombinedPath SampledPath(Eyesubpath, Lightsubpath);
//////////////////////////////////////////////////////////////////////////
// main evaluation
// evaluate the path
vec3d f = vec3d(pathThroughputWeighted(SampledPath));
// this could be tricky
// vec3 ff =
// SampledPath.eyeEnd().getThroughput(); if
// (SampledPath.lightSize() == 0)
// {
// ff *=
// SampledPath.lightEnd().getThroughput();
// }
// else
// {
// ff *=
// todo_getMaterial(SampledPath.eyeEnd()->getMaterialID()).getBSDF()->evaluate(vec3(),
// normal, vec3())
// }
// vec3d f = vec3d(ff);
// uniform weighting
// this also seems to work
// int num_non_specs = SampledPath.numNonSpecularEdges();
// double path_weight = (1.0 / (num_non_specs + 1));
// path mis
double path_weight = calculateMisWeight(
SampledPath); // double precision is important
// assert(path_weight == path_weight);
if (path_weight != path_weight)
{
path_weight = 0;
}
vec3 c = (f * path_weight)
.toFloat(); // Monte Carlo integration formula
//////////////////////////////////////////////////////////////////////////
if (isZero(c))
{
continue;
}
// store the pixel contribution (pushback style)
Result.c[Result.n] =
Contribution(px, py, c, NumLightVertices, NumEyeVertices);
Result.n++;
// scalar contribution function
Result.sc = f_max(maxComponent(c), Result.sc);
// return immediately if the technique is specified
if (Specified && (SpecifiedNumEyeVertices == NumEyeVertices) &&
(SpecifiedNumLightVertices == NumLightVertices))
{
return Result;
}
}
}
return Result;
}
// accumulate the pixel contributions of a path onto the film (note that
// normalization for sample numbers is done when writing to image)
void AccumulatePathContribution(const PathContribution pc)
{
if (pc.sc == 0)
{
return;
}
for (int i = 0; i < pc.n; i++)
{
const int ix = int(pc.c[i].x),
iy = int(pc.c[i].y); // pixel index, no advanced
// reconstruction filter is used
const vec3 c = pc.c[i].c; // scaled pixel contribution
film.accumulatePixel(ix, iy, c);
}
for (int i = 0; i < pc.n; i++)
{
const int ix = int(pc.c[i].x),
iy = int(pc.c[i].y); // pixel index, no advanced
// reconstruction filter is used
const vec3 c = pc.c[i].c; // scaled pixel contribution
int s = pc.c[i].s;
int t = pc.c[i].t;
pyramid[s * MaxEvents + t].accumulatePixel(ix, iy, c);
}
}
double calculatePdfA(const std::vector<const Vert*>& vs,
const int from_idx,
const int next_idx)
{
const Vert& from_vertex = *vs[from_idx];
const Vert& next_vertex = *vs[next_idx];
const int prev_from_idx = (from_idx - next_idx) + from_idx;
Vert const* prev_from_vertex = nullptr;
if (0 <= prev_from_idx && prev_from_idx < vs.size())
{
prev_from_vertex = vs[prev_from_idx];
}
const vec3 to = next_vertex.p - from_vertex.p;
const vec3 normalized_to = normalize(to);
double pdf = 0;
switch (from_vertex.debug_vertex_type)
{
default:
case Lens:
return camera.measurementFunction(
next_vertex); // pdfA of sampling the next vertex
break;
case Emitter:
case Diffuse:
pdf = todo_getMaterial(from_vertex.obj->materialID())
.pdfW(vec3(0, 0, 0), from_vertex.n, normalized_to);
break;
case Specular:
// pdf = 1;
pdf = from_vertex.pWo;
break;
}
// pdfW to pdfA
const vec3 next_new_orienting_normal =
dot(to, next_vertex.n) < 0 ? next_vertex.n : -next_vertex.n;
return pdf *
(dot(-normalized_to, next_new_orienting_normal) / dot(to, to));
}
double calculateMisWeight(const CombinedPath& path)
{
int t = path.eyeSize();
int s = path.lightSize();
std::vector<double> pi1_pi(t + s); // p_i+1 over p_i
std::vector<const Vert*> vs(t + s);
double PA_y0 = 1.0 / scene.lightArea();
double PA_x0 = 1.0;
std::vector<std::pair<double, double> > debug_p(s + t);
const int k = t + s - 1;
for (int i = 0; i < path.size(); i++)
{
vs[i] = &path[k - i];
}
pi1_pi[0] = PA_y0 / (calculatePdfA(vs, 1, 0));
debug_p[0] = std::make_pair(PA_y0, calculatePdfA(vs, 1, 0));
for (int i = 1; i < k; i++)
{
double a = calculatePdfA(vs, i - 1, i);
double b = calculatePdfA(vs, i + 1, i);
pi1_pi[i] = a / b;
debug_p[i] = std::make_pair(a, b);
}
pi1_pi[k] = calculatePdfA(vs, k - 1, k) / PA_x0;
debug_p[k] = std::make_pair(calculatePdfA(vs, k - 1, k), PA_x0);
std::vector<double> p(t + s + 1);
p[s] = 1; // pdf for (s,t) path
// this is not necessary
// if (path.eyeSize() > 0)
// {
// p[s] *= path.eyeEnd().getTotalPdfA();
// }
// if (path.lightSize() > 0)
// {
// p[s] *= path.lightEnd().getTotalPdfA();
// }
for (int i = s; i <= k; i++)
{
p[i + 1] = p[i] * pi1_pi[i];
}
for (int i = s - 1; i >= 0; i--)
{
p[i] = p[i + 1] / pi1_pi[i];
}
for (int i = 0; i < vs.size() - 1; i++)
{
if (todo_getMaterial(vs[i]->obj->materialID()).isDelta())
{
p[i] = 0;
p[i + 1] = 0;
}
}
double mis_weight = 0;
for (int i = 0; i < p.size(); i++)
{
double v = p[i] / p[s];
mis_weight += v * v;
}
if (mis_weight != mis_weight)
{
return 0;
}
// if (s == 0 && t == 6 && mis_weight < 10)
// {
// cout << "[ " << s << ", " << t << " ] " << mis_weight <<
// endl;
// }
// if (s == 0)
// return 0;
return 1.0 / mis_weight;
}
//////////////////////////////////////////////////////////////////////////
vec3d pathThroughputWeighted(const CombinedPath& path)
{
vec3 f = vec3(1.0, 1.0, 1.0);
// eye path inner weight
for (int i = 1; i <= path.eyeSize() - 2; i++)
{
const Material& mat =
todo_getMaterial(path.eye(i).obj->materialID());
const vec3 d0 = normalize(path.eye(i - 1).p - path.eye(i).p);
const vec3 d1 = normalize(path.eye(i + 1).p - path.eye(i).p);
vec3 bsdf_weight = vec3(0.0); // reflecting brdf
if (!mat.isLight())
{
bsdf_weight = path.eye(i).weight; // includes color
bsdf_weight *= path.eye(i).cos_wo;
bsdf_weight *= 1.0f / path.eye(i).pWo;
}
f *= bsdf_weight;
}
// light path inner weight
for (int j = 1; j <= path.lightSize() - 2; j++)
{
const Material& mat =
todo_getMaterial(path.light(j).obj->materialID());
const vec3 d0 = normalize(path.light(j - 1).p - path.light(j).p);
const vec3 d1 = normalize(path.light(j + 1).p - path.light(j).p);
vec3 bsdf_weight = vec3(0.0); // reflecting brdf
if (!mat.isLight())
{
bsdf_weight = path.light(j).weight; // includes color
bsdf_weight *= path.light(j).cos_wo;
bsdf_weight *= 1.0f / path.light(j).pWo;
}
f *= bsdf_weight;
}
//////////////////////////////////////////////////////////////////////////
if (path.eyeSize() == 1)
{
f *= camera.measurementFunction(path.lightEnd());
}
if (path.lightSize() == 0)
{
if (path.eyeSize() > 1)
{
const Material& mat_eye_end =
todo_getMaterial(path.eyeEnd().obj->materialID());
vec3 L = vec3(0);
if (mat_eye_end.isLight())
{
vec3 dir = path.eye(path.eyeSize() - 2).p - path.eyeEnd().p;
if (dot(dir, path.eyeEnd().n) > 0)
{
// L = mat_eye_end.color() / NUM_PI;
// // light
L = mat_eye_end.color(); // light
}
}
f *= L;
}
}
if (path.lightSize() == 1)
{
float pdfA = 1.0f / scene.lightArea();
f *= 1.0f / pdfA;
if (path.eyeSize() > 1)
{
const Material& mat_eye_end =
todo_getMaterial(path.eyeEnd().obj->materialID());
vec3 bsdf_eye_end = vec3(0.0); // reflecting brdf
if (!mat_eye_end.isLight())
{
const vec3 d0 = normalize(path.eye(path.eyeSize() - 2).p -
path.eyeEnd().p);
const vec3 d1 =
normalize(path.lightEnd().p - path.eyeEnd().p);
bsdf_eye_end = mat_eye_end.evaluate(
d0, path.eyeEnd().n, d1); // includes color
bsdf_eye_end *=
geometryTerm(path.eyeEnd(), path.lightEnd());
}
f *= bsdf_eye_end;
const Material& mat_light_end =
todo_getMaterial(path.lightEnd().obj->materialID());
vec3 L = vec3(0);
if (mat_light_end.isLight())
{
vec3 dir = path.light(1).p - path.light(0).p;
if (dot(dir, path.light(0).n) > 0)
{
// L = mat_light_end.color() /
// NUM_PI; // light
L = mat_light_end.color(); // light
}
}
f *= L;
}
}
if (path.lightSize() > 1)
{
const Material& mat_light_end =
todo_getMaterial(path.lightEnd().obj->materialID());
vec3 bsdf_light_end = vec3(0.0); // reflecting brdf
if (!mat_light_end.isLight())
{
const vec3 d0 = normalize(path.light(path.lightSize() - 2).p -
path.lightEnd().p);
const vec3 d1 = normalize(path.eyeEnd().p - path.lightEnd().p);
bsdf_light_end =
mat_light_end.evaluate(d0, path.lightEnd().n, d1);
}
f *= bsdf_light_end;
const Material& mat_light =
todo_getMaterial(path.light(0).obj->materialID());
assert(mat_light.type() == LGHT);
vec3 L = vec3(0);
if (mat_light.isLight())
{
vec3 dir = path.light(1).p - path.light(0).p;
if (dot(dir, path.light(0).n) > 0)
{
// L = mat_light.color(); // light
L = mat_light.color() * NUM_PI; // light (pdfW = cos / pi,
// pdfA = cos' / r^2 * cos
// / pi, thus cancelled
// with G, becomes 1 / pi)
}
}
f *= L;
float pdfA = 1.0f / scene.lightArea();
f *= 1.0f / pdfA;
if (path.eyeSize() > 1)
{
const Material& mat_eye_end =
todo_getMaterial(path.eyeEnd().obj->materialID());
vec3 bsdf_eye_end = vec3(0.0); // reflecting brdf
if (!mat_eye_end.isLight())
{
const vec3 d0 = normalize(path.eye(path.eyeSize() - 2).p -
path.eyeEnd().p);
const vec3 d1 =
normalize(path.lightEnd().p - path.eyeEnd().p);
bsdf_eye_end = mat_eye_end.evaluate(
d0, path.eyeEnd().n, d1); // includes color
bsdf_eye_end *=
geometryTerm(path.eyeEnd(), path.lightEnd());
}
f *= bsdf_eye_end;
}
}
return vec3d(f);
}
public:
ReferenceBDPT(const Camera& camera, FrameBuffer& film, const Scene& scene)
: camera(camera), film(film), scene(scene)
{
pyramid.resize(MaxEvents * MaxEvents);
for (auto& m : pyramid)
{
m.resize(film.width(), film.height());
}
}
void render(const int MaxEyeEvents, StandardSampler& sampler)
{
// sample the path
Path eye_path = GenerateEyePath(MaxEyeEvents, sampler);
Path light_path = GenerateLightPath(MaxEyeEvents, sampler);
PathContribution pc = CombinePaths(eye_path, light_path);
// accumulate samples
if (pc.sc > 0.0)
{
AccumulatePathContribution(pc);
}
}
void dumpPyramid(float scale)
{
system("mkdir pyramid");
for (int s = 0; s < MaxEvents; s++)
{
for (int t = 1; t < MaxEvents; t++)
{
if (s + t > MaxEvents)
{
continue;
}
auto& img = pyramid[s * MaxEvents + t];
std::string filename = std::string("pyramid/bdpt_s") + str(s) +
"_t" + str(t) + ".ppm";
img.scale(scale);
img.tonemapGamma(2.2f);
img.dumpPPM(filename.c_str());
}
}
}
};
#endif // bdpt_h__
|
RNG65536/MCRT
|
src/core/lightpath.h
|
#pragma once
#include "vectors.h"
#define MinPathLength 1
#define MaxPathLength 11 // 9 // 10
#define MaxEvents (MaxPathLength + 1)
typedef enum { FromEye, FromLight } PathType;
typedef enum { Emitter, Diffuse, Specular, Lens } VertexType;
class TriangleObject;
// path data
class Vert
{
private:
char m_delta_flag;
double m_total_pdfA;
vec3 m_orienting_normal;
vec3 m_throughput;
public:
vec3 p; // position
vec3 n; // intrinsic geometry normal
const TriangleObject* obj = nullptr;
vec3 weight; // bsdf_weight returned by bsdf.sample()
float pWo; // forward pdfW, returned by bsdf.sample()
float pWi; // backward pdfW
float cos_wo;
vec3 debug_wi;
vec3 debug_wo;
PathType debug_type;
VertexType debug_vertex_type;
Vert();
Vert(vec3 _p, vec3 _n, const TriangleObject* _obj = nullptr);
bool canConnectTo(const vec3& position) const;
void setDeltaFlag(char flag);
char isDelta() const;
void setTotalPdfA(double pdf);
double getTotalPdfA() const;
void setOrientingNormal(const vec3& n);
const vec3& getOrientingNormal() const;
void setThroughput(const vec3& t);
const vec3& getThroughput() const;
};
// the light path, represented as a vector of vertices
class Path
{
Vert x[MaxEvents];
int n_verts = 0; // path length
public:
Path();
const Vert& operator[](int i) const;
Vert& operator[](int i);
const Vert& begin() const;
Vert& begin();
const Vert& end() const;
Vert& end();
void insert(const Vert& v);
int size() const;
void resize(int _n);
Path subpath(int n) const;
};
class CombinedPath
{
Path path;
int num_eye_verts;
int num_light_verts;
int path_length;
public:
CombinedPath(const Path& eye, const Path& light);
Vert& operator[](int i);
const Vert& operator[](int i) const;
int size() const;
int eyeSize() const;
int lightSize() const;
int toLightIndex(int i) const;
int toEyeIndex(int i) const;
const Vert& eye(int i) const;
Vert& eye(int i);
const Vert& light(int i) const;
Vert& light(int i);
const Vert& eyeBegin() const;
const Vert& eyeEnd() const;
const Vert& lightBegin() const;
const Vert& lightEnd() const;
Vert& eyeBegin();
Vert& eyeEnd();
Vert& lightBegin();
Vert& lightEnd();
int numNonSpecularEdges() const;
};
// pixel contribution
class Contribution
{
public:
float x, y; // pixel coordinates
vec3 c; // pixel color
int s, t;
Contribution();
Contribution(float x_, float y_, vec3 c_, int s_ = -1, int t_ = -1);
};
// pixel contributions of subpaths of different combinations
class PathContribution
{
public:
Contribution c[MaxEvents * MaxEvents];
int n;
float sc; // scalar contribution ??
PathContribution();
};
|
RNG65536/MCRT
|
src/core/mesh.h
|
#pragma once
#include <glm/glm.hpp>
#include <string>
#include <vector>
#include "vectors.h"
// obj mesh loader
class Mesh
{
public:
Mesh();
std::vector<vec3> m_verts;
std::vector<int3> m_faces;
std::vector<vec3> m_vertex_normals;
std::vector<float> m_vertex_alpha;
Mesh(const std::string& filename);
void genNormals();
void flipSide();
void transform(const glm::mat4& mat);
void dumpBinary(const std::string& binfile) const;
void loadBinary(const std::string& binfile);
};
|
RNG65536/MCRT
|
src/core/triangle.h
|
<filename>src/core/triangle.h
#pragma once
#include "intersection.h"
#include "ray.h"
#include "vectors.h"
// triangle object
class AABB;
class TriangleObject
{
public:
int materialID() const;
void setMaterialID(int id);
void setVertexAlpha(const vec3& alpha); // for consistent normal
const int& primitiveID() const;
void setPrimitiveID(int id);
TriangleObject();
TriangleObject(vec3 a, vec3 b, vec3 c);
TriangleObject(vec3 a, vec3 b, vec3 c, vec3 na, vec3 nb, vec3 nc);
float area() const;
vec3 baryCenter() const;
vec3 normal() const;
vec3 consistentNormal(const vec3& wi,
float u,
float v,
vec3* refl = nullptr,
float* cos_wi = nullptr) const;
// interpolation using barycentric coordinates
vec3 normal(float u, float v) const;
vec3 point(float u, float v) const;
// uniform sampling
vec3 samplePoint() const;
vec3 samplePoint(float& u, float& v) const;
vec3 samplePoint(float& u, float& v, float r0, float r1) const;
AABB boundingBox() const;
bool intersect(Ray& ray, HitInfo& hit_info) const;
std::string toString() const;
static void setIntersectionEpsilon(float eps);
public:
vec3 a, b, c; // vertices
vec3 n, na, nb, nc; // face normal and vertex normals
vec3 m_vertex_alpha; // for consistent normal
private:
int m_matID;
int m_objID;
static float s_intersection_epsilon;
};
typedef TriangleObject Triangle;
|
RNG65536/MCRT
|
src/core/texture.h
|
<filename>src/core/texture.h<gh_stars>1-10
#pragma once
class Texture
{
public:
};
|
RNG65536/MCRT
|
src/core/ray.h
|
<gh_stars>1-10
#pragma once
#include <string>
#include "vectors.h"
// ray
class Ray
{
public:
Ray();
// NOTE that additional dir info is recomputed
Ray(const Ray& ray);
Ray(const float3& o_, const float3& d_);
Ray(const float3& o_, const float3& d_, float tmin, float tmax);
// normalize direction
Ray normalize() const;
// point t units away from the ray origin
vec3 at(float t) const;
static void set_ray_epsilon(float eps);
std::string toString() const;
public:
float3 orig; // origin
float tmin; // minimum valid t
float3 dir; // direction
float tmax; // maximum valid t
float3 inv_dir; // direction reciprocal
byte3 dir_sign; // direction sign
static float s_ray_epsilon;
};
|
RNG65536/MCRT
|
src/examples/splitbvh/debug_mesh.h
|
#pragma once
#include <vector>
#include "triangle.h"
#include "aabb.h"
class DebugMesh
{
public:
DebugMesh();
std::vector<Triangle>::const_iterator begin() const
{
return m_triangles.cbegin();
}
std::vector<Triangle>::const_iterator end() const
{
return m_triangles.cend();
}
const AABB& boundingBox() const
{
return m_boundingBox;
}
const std::vector<Triangle>& triangles() const
{
return m_triangles;
}
bool intersect(Ray& ray, HitInfo& hit_info) const;
private:
void initMesh();
void initRandomMesh();
std::vector<Triangle> m_triangles;
AABB m_boundingBox;
};
|
RNG65536/MCRT
|
src/examples/vcm/vcm_material.h
|
// Disclaimer: This demo is adapted from smallvcm http://www.smallvcm.com/
#pragma once
#include "vectors.h"
#include "geometry.h"
#include "ray.h"
#include "sample.h"
#include "constants.h"
#include "numeric.h"
class Material_debug
{
public:
Material_debug()
{
Reset();
}
void Reset()
{
m_diffuseReflectance = vec3(0);
m_phongReflectance = vec3(0);
m_phongExponent = 1.0f;
m_mirrorReflectance = vec3(0);
m_IOR = -1.0f;
}
// diffuse is simply added to the others
vec3 m_diffuseReflectance;
// Phong is simply added to the others
vec3 m_phongReflectance;
float m_phongExponent;
// mirror can be either simply added, or mixed using Fresnel term
// this is governed by mIOR, if it is >= 0, fresnel is used, otherwise
// it is not
vec3 m_mirrorReflectance;
// When mIOR >= 0, we also transmit (just clear glass)
float m_IOR;
};
//////////////////////////////////////////////////////////////////////////
// BSDF, most magic happens here
//
// One of important conventions is prefixing direction with World when they
// are in world coordinates and with Local when they are in local frame,
// i.e., mFrame.
//
// Another important convention is suffix Fix and Gen.
// For PDF computation, we need to know which direction is given (Fix),
// and which is the generated (Gen) direction. This is important even
// when simply evaluating BSDF.
// In BPT, we call Evaluate() when directly connecting to light/camera.
// This gives us both directions required for evaluating BSDF.
// However, for MIS we also need to know probabilities of having sampled
// this path via BSDF sampling, and we need that for both possible directions.
// The Fix/Gen convention (along with Direct and Reverse for PDF) clearly
// establishes which PDF is which.
//
// The BSDF is also templated by direction of tracing, whether from camera
// (BSDF<false>) or from light (BSDF<true>). This is identical to Veach's
// Adjoint BSDF (except the name is more straightforward).
// For us this is only used when refracting.
#define EPS_PHONG 1e-3f
template<bool FixIsLight>
class BSDF
{
private:
struct ComponentProbabilities
{
float m_diffProb;
float m_phongProb;
float m_reflProb;
float m_refrProb;
};
private:
const Material_debug *m_material = nullptr; //!< * of scene material, nullptr ~ invalid
OrthonormalFrame m_frame; //!< Local frame of reference
vec3 m_localDirFix; //!< Incoming (fixed) direction, in local
bool m_isDelta; //!< True when material is purely specular
ComponentProbabilities m_probabilities; //!< Sampling probabilities
float m_continuationProb; //!< Russian roulette probability
float m_reflectCoeff; //!< Fresnel reflection coefficient (for glass)
public:
enum Events
{
kNONE = 0,
kDiffuse = 1,
kPhong = 2,
kReflect = 4,
kRefract = 8,
kSpecular = (kReflect | kRefract),
kNonSpecular = (kDiffuse | kPhong),
kAll = (kSpecular | kNonSpecular)
};
public:
BSDF() {};
BSDF(
const Ray& _ray,
const vec3& _normal,
const Material_debug *_mat)
{
m_frame.setFromNormal(_normal);
m_localDirFix = m_frame.toLocal(-_ray.dir);
// reject rays that are too parallel with tangent plane
if (std::abs(m_localDirFix.z) < NUM_EPS_COSINE)
{
return;
}
m_material = _mat;
const Material_debug &mat = *m_material;
GetComponentProbabilities(mat, m_probabilities);
m_isDelta = (m_probabilities.m_diffProb == 0) && (m_probabilities.m_phongProb == 0);
}
/* \brief Given a direction, evaluates BSDF
*
* Returns value of BSDF, as well as cosine for the
* aWorldDirGen direction.
* Can return probability (w.r.t. solid angle W),
* of having sampled aWorldDirGen given mLocalDirFix (oDirectPdfW),
* and of having sampled mLocalDirFix given aWorldDirGen (oReversePdfW).
*
*/
vec3 Evaluate(
const vec3& _worldDirGen,
float& cosThetaGen_,
float *directPdfW_ = nullptr,
float *reversePdfW_ = nullptr) const
{
vec3 result(0);
if (directPdfW_)
{
*directPdfW_ = 0;
}
if (reversePdfW_)
{
*reversePdfW_ = 0;
}
const vec3 localDirGen = m_frame.toLocal(_worldDirGen);
if (localDirGen.z * m_localDirFix.z < 0)
{
return result;
}
cosThetaGen_ = std::abs(localDirGen.z);
const Material_debug &mat = *m_material;
result += EvaluateDiffuse(mat, localDirGen, directPdfW_, reversePdfW_);
result += EvaluatePhong(mat, localDirGen, directPdfW_, reversePdfW_);
return result;
}
/* \brief Given a direction, evaluates Pdf
*
* By default returns PDF with which would be aWorldDirGen
* generated from mLocalDirFix. When aEvalRevPdf == true,
* it provides PDF for the reverse direction.
*/
float Pdf(
const vec3& _worldDirGen,
const bool _evalRevPdf = false) const
{
const vec3 localDirGen = m_frame.toLocal(_worldDirGen);
if (localDirGen.z * m_localDirFix.z < 0)
{
return 0;
}
const Material_debug &mat = *m_material;
float directPdfW = 0;
float reversePdfW = 0;
PdfDiffuse(mat, localDirGen, &directPdfW, &reversePdfW);
PdfPhong(mat, localDirGen, &directPdfW, &reversePdfW);
return _evalRevPdf ? reversePdfW : directPdfW;
}
/* \brief Given 3 random numbers, samples new direction from BSDF.
*
* Uses z component of random triplet to pick BSDF component from
* which it will sample direction. If non-specular component is chosen,
* it will also evaluate the other (non-specular) BSDF components.
* Return BSDF factor for given direction, as well as PDF choosing that direction.
* Can return event which has been sampled.
* If result is Vec3f(0,0,0), then the sample should be discarded.
*/
vec3 Sample(
const vec3& _rndTriplet,
vec3& worldDirGen_,
float& pdfW_,
float& cosThetaGen_,
uint32_t *sampledEvent_ = nullptr) const
{
uint32_t sampledEvent;
if (_rndTriplet.z < m_probabilities.m_diffProb)
{
sampledEvent = kDiffuse;
}
else if (_rndTriplet.z < m_probabilities.m_diffProb + m_probabilities.m_phongProb)
{
sampledEvent = kPhong;
}
else if (_rndTriplet.z < m_probabilities.m_diffProb + m_probabilities.m_phongProb + m_probabilities.m_reflProb)
{
sampledEvent = kReflect;
}
else
{
sampledEvent = kRefract;
}
if (sampledEvent_)
{
*sampledEvent_ = sampledEvent;
}
const Material_debug &mat = *m_material;
pdfW_ = 0;
vec3 result(0);
vec3 localDirGen;
if (sampledEvent == kDiffuse)
{
result += SampleDiffuse(mat, vec2(_rndTriplet.x, _rndTriplet.y, 0), localDirGen, pdfW_);
if (isZero(result))
{
return vec3(0);
}
result += EvaluatePhong(mat, localDirGen, &pdfW_);
}
else if (sampledEvent == kPhong)
{
result += SamplePhong(mat, vec2(_rndTriplet.x, _rndTriplet.y, 0), localDirGen, pdfW_);
if (isZero(result))
{
return vec3(0);
}
result += EvaluateDiffuse(mat, localDirGen, &pdfW_);
}
else if (sampledEvent == kReflect)
{
result += SampleReflect(mat, vec2(_rndTriplet.x, _rndTriplet.y, 0), localDirGen, pdfW_);
if (isZero(result))
{
return vec3(0);
}
}
else
{
result += SampleRefract(mat, vec2(_rndTriplet.x, _rndTriplet.y, 0), localDirGen, pdfW_);
if (isZero(result))
{
return vec3(0);
}
}
cosThetaGen_ = std::abs(localDirGen.z);
if (cosThetaGen_ < NUM_EPS_COSINE)
{
return vec3(0.0f);
}
worldDirGen_ = m_frame.toWorld(localDirGen);
return result;
}
bool IsValid() const { return nullptr != m_material; }
bool IsDelta() const { return m_isDelta; }
float ContinuationProb() const { return m_continuationProb; }
float CosThetaFix() const { return m_localDirFix.z; }
vec3 WorldDirFix() const { return m_frame.toWorld(m_localDirFix); }
private:
////////////////////////////////////////////////////////////////////////////
// Sampling methods
// All sampling methods take material, 2 random numbers [0-1[,
// and return BSDF factor, generated direction in local coordinates, and PDF
////////////////////////////////////////////////////////////////////////////
vec3 SampleDiffuse(
const Material_debug& _material,
const vec2& _rndTuple,
vec3& localDirGen_,
float& pdfW_) const
{
if (m_localDirFix.z < NUM_EPS_COSINE)
return vec3(0);
float unweightedPdfW;
localDirGen_ = sampleHemisphereCosineW(_rndTuple.x, _rndTuple.y, &unweightedPdfW);
pdfW_ += unweightedPdfW * m_probabilities.m_diffProb;
return _material.m_diffuseReflectance / NUM_PI;
}
vec3 SamplePhong(
const Material_debug& _material,
const vec2& _rndTuple,
vec3& localDirGen_,
float& pdfW_) const
{
localDirGen_ = sampleHemisphereCosinePowerW(_rndTuple.x, _rndTuple.y, _material.m_phongExponent, nullptr);
// Due to numeric issues in MIS, we actually need to compute all pdfs
// exactly the same way all the time!!!
const vec3 reflLocalDirFixed = reflectLocal(m_localDirFix);
{
OrthonormalFrame frame;
frame.setFromNormal(reflLocalDirFixed);
localDirGen_ = frame.toWorld(localDirGen_);
}
const float dot_R_Wi = dot(reflLocalDirFixed, localDirGen_);
if (dot_R_Wi <= EPS_PHONG)
{
return vec3(0.0f);
}
PdfPhong(_material, localDirGen_, &pdfW_);
const vec3 rho = _material.m_phongReflectance *
(_material.m_phongExponent + 2.0f) * 0.5f / NUM_PI;
return rho * std::pow(dot_R_Wi, _material.m_phongExponent);
}
vec3 SampleReflect(
const Material_debug& _material,
const vec2& _rndTuple,
vec3& localDirGen_,
float& pdfW_) const
{
localDirGen_ = reflectLocal(m_localDirFix);
pdfW_ += m_probabilities.m_reflProb;
// BSDF is multiplied (outside) by cosine (oLocalDirGen.z),
// for mirror this shouldn't be done, so we pre-divide here instead
return m_reflectCoeff * _material.m_mirrorReflectance /
std::abs(localDirGen_.z);
}
vec3 SampleRefract(
const Material_debug& _material,
const vec2& _rndTuple,
vec3& localDirGen_,
float& pdfW_) const
{
if (_material.m_IOR < 0)
{
return vec3(0);
}
float cosI = m_localDirFix.z;
float cosT;
float etaIncOverEtaTrans;
if (cosI < 0.0f) // hit from inside
{
etaIncOverEtaTrans = _material.m_IOR;
cosI = -cosI;
cosT = 1.0f;
}
else
{
etaIncOverEtaTrans = 1.0f / _material.m_IOR;
cosT = -1.0f;
}
const float sinI2 = 1.0f - cosI * cosI;
const float sinT2 = sq(etaIncOverEtaTrans) * sinI2;
if (sinT2 < 1.0f) // no total internal reflection
{
cosT *= std::sqrt(f_max(0.0f, 1.0f - sinT2));
localDirGen_ = vec3(
-etaIncOverEtaTrans * m_localDirFix.x,
-etaIncOverEtaTrans * m_localDirFix.y,
cosT);
pdfW_ += m_probabilities.m_refrProb;
const float refractCoeff = 1.0f - m_reflectCoeff;
// only camera paths are multiplied by this factor, and etas
// are swapped because radiance flows in the opposite direction
if (!FixIsLight)
{
return vec3(refractCoeff * sq(etaIncOverEtaTrans) / std::abs(cosT));
}
else
{
return vec3(refractCoeff / std::abs(cosT));
}
}
//else total internal reflection, do nothing
// because it is sampled as reflection ??
pdfW_ += 0.0f;
return vec3(0.0f);
}
////////////////////////////////////////////////////////////////////////////
// Evaluation methods
////////////////////////////////////////////////////////////////////////////
vec3 EvaluateDiffuse(
const Material_debug& _material,
const vec3& _localDirGen,
float *directPdfW_ = nullptr,
float *reversePdfW_ = nullptr) const
{
if (m_probabilities.m_diffProb == 0)
{
return vec3(0);
}
if (m_localDirFix.z < NUM_EPS_COSINE || _localDirGen.z < NUM_EPS_COSINE)
{
return vec3(0);
}
if (directPdfW_)
{
*directPdfW_ += m_probabilities.m_diffProb * f_max(0.0f, _localDirGen.z / NUM_PI);
}
if (reversePdfW_)
{
*reversePdfW_ += m_probabilities.m_diffProb * f_max(0.0f, m_localDirFix.z / NUM_PI);
}
return _material.m_diffuseReflectance / NUM_PI;
}
vec3 EvaluatePhong(
const Material_debug& _material,
const vec3& _localDirGen,
float *directPdfW_ = nullptr,
float *reversePdfW_ = nullptr) const
{
if (m_probabilities.m_phongProb == 0)
{
return vec3(0);
}
if (m_localDirFix.z < NUM_EPS_COSINE || _localDirGen.z < NUM_EPS_COSINE)
{
return vec3(0);
}
// assumes this is never called when rejectShadingCos(oLocalDirGen.z) is true
const vec3 reflLocalDirIn = reflectLocal(m_localDirFix);
const float dot_R_Wi = dot(reflLocalDirIn, _localDirGen);
if (dot_R_Wi <= EPS_PHONG)
{
return vec3(0.0f);
}
if (directPdfW_ || reversePdfW_)
{
// the sampling is symmetric
const float pdfW = m_probabilities.m_phongProb *
sampleHemisphereCosinePowerPdfW(reflLocalDirIn, _localDirGen, _material.m_phongExponent);
if (directPdfW_)
{
*directPdfW_ += pdfW;
}
if (reversePdfW_)
{
*reversePdfW_ += pdfW;
}
}
const vec3 rho = _material.m_phongReflectance *
(_material.m_phongExponent + 2.0f) * 0.5f / NUM_PI;
return rho * std::pow(dot_R_Wi, _material.m_phongExponent);
}
////////////////////////////////////////////////////////////////////////////
// Pdf methods
////////////////////////////////////////////////////////////////////////////
void PdfDiffuse(
const Material_debug& _material,
const vec3& _localDirGen,
float *directPdfW_ = nullptr,
float *reversePdfW_ = nullptr) const
{
if (m_probabilities.m_diffProb == 0)
{
return;
}
if (directPdfW_)
{
*directPdfW_ += m_probabilities.m_diffProb *
f_max(0.0f, _localDirGen.z / NUM_PI);
}
if (reversePdfW_)
{
*reversePdfW_ += m_probabilities.m_diffProb *
f_max(0.0f, m_localDirFix.z / NUM_PI);
}
}
void PdfPhong(
const Material_debug& _material,
const vec3& _localDirGen,
float *directPdfW_ = nullptr,
float *reversePdfW_ = nullptr) const
{
if (m_probabilities.m_phongProb == 0)
{
return;
}
// assumes this is never called when rejectShadingCos(oLocalDirGen.z) is true
const vec3 reflLocalDirIn = reflectLocal(m_localDirFix);
const float dot_R_Wi = dot(reflLocalDirIn, _localDirGen);
if (dot_R_Wi <= EPS_PHONG)
{
return;
}
if (directPdfW_ || reversePdfW_)
{
// the sampling is symmetric
const float pdfW = sampleHemisphereCosinePowerPdfW(reflLocalDirIn, _localDirGen,
_material.m_phongExponent) * m_probabilities.m_phongProb;
if (directPdfW_)
{
*directPdfW_ += pdfW;
}
if (reversePdfW_)
{
*reversePdfW_ += pdfW;
}
}
}
////////////////////////////////////////////////////////////////////////////
// Albedo methods
////////////////////////////////////////////////////////////////////////////
float AlbedoDiffuse(const Material_debug& _material) const
{
return luminance(_material.m_diffuseReflectance);
}
float AlbedoPhong(const Material_debug& _material) const
{
return luminance(_material.m_phongReflectance);
}
float AlbedoReflect(const Material_debug& _material) const
{
return luminance(_material.m_mirrorReflectance);
}
float AlbedoRefract(const Material_debug& _material) const
{
return _material.m_IOR > 0.0f ? 1.0f : 0.0f;
}
void GetComponentProbabilities(
const Material_debug &_material,
ComponentProbabilities &probabilities_)
{
m_reflectCoeff = fresnelReflectance(m_localDirFix.z, _material.m_IOR);
const float albedoDiffuse = AlbedoDiffuse(_material);
const float albedoPhong = AlbedoPhong(_material);
const float albedoReflect = m_reflectCoeff * AlbedoReflect(_material);
const float albedoRefract = (1.0f - m_reflectCoeff) * AlbedoRefract(_material);
const float totalAlbedo = albedoDiffuse + albedoPhong + albedoReflect + albedoRefract;
if (totalAlbedo < 1e-9f)
{
probabilities_.m_diffProb = 0.0f;
probabilities_.m_phongProb = 0.0f;
probabilities_.m_reflProb = 0.0f;
probabilities_.m_refrProb = 0.0f;
m_continuationProb = 0.0f;
}
else
{
probabilities_.m_diffProb = albedoDiffuse / totalAlbedo;
probabilities_.m_phongProb = albedoPhong / totalAlbedo;
probabilities_.m_reflProb = albedoReflect / totalAlbedo;
probabilities_.m_refrProb = albedoRefract / totalAlbedo;
// The continuation probability is max component from reflectance.
// That way the weight of sample will never rise.
// Luminance is another very valid option.
m_continuationProb =
maxComponent(_material.m_diffuseReflectance +
_material.m_phongReflectance +
m_reflectCoeff * _material.m_mirrorReflectance) +
(1.0f - m_reflectCoeff);
m_continuationProb = clampf(m_continuationProb, 0.0f, 1.0f);
}
}
};
|
RNG65536/MCRT
|
src/core/scene.h
|
<filename>src/core/scene.h
#pragma once
#include <glm/glm.hpp>
#include <unordered_map>
#include "camera.h"
#include "constants.h"
#include "envmap.h"
#include "intersection.h"
#include "material.h"
#include "ray.h"
#include "sample.h"
#include "triangle.h"
#include "vectors.h"
// scene management
class SceneBVH;
class DiscreteSampler;
class SceneSphere
{
public:
vec3 m_cenetr;
float m_radius;
float m_inv_radius_sqr;
};
class Scene
{
public:
Scene();
~Scene();
void clear();
void finalize();
void add(const TriangleObject& object);
void setCamera(const vec3& origin,
const vec3& target,
int width,
int height,
float fov_y);
// environment map
void setEnvmap(const std::string filename);
void setEnvmap(const std::string filename, int width, int height);
EnvmapLoader* envmap() const;
// other lights
float lightArea() const;
float lightPdfW(const vec3& pos, const vec3& nl, const vec3& dir) const;
vec3 lightRadiance(const vec3& pos,
const vec3& dir,
const int light_id = -1) const;
void sampleLightAreaAndDirection(
vec3& position,
vec3& normal,
float& pdfA,
vec3& direction,
float& pdfW,
const TriangleObject*& obj,
StandardSampler& sampler) const; // assuming diffuse emission
vec3 sampleLightArea(const vec3& position,
float& pdfW,
int& light_id,
vec3* sample_pos = nullptr,
vec3* sample_normal = nullptr) const;
void sampleLight(float& pdfLight,
int& light_id,
vec3& sample_pos,
vec3& sample_normal,
float rnd0,
float rnd1,
float rnd2) const;
// intersection
HitInfo intersect(const Ray& ray) const;
bool occluded(const Ray& ray, float tfar = NUM_INFINITY) const;
// scene objects
TriangleObject& triangle(size_t n);
const TriangleObject& triangle(size_t n) const;
float triangleArea(size_t n) const;
Camera* camera() const;
size_t numTrangles() const;
vec3 boxCenter() const;
const SceneSphere& boundingSphere() const;
void loadModel(const std::string& filename,
const glm::mat4& transform,
const Material& mat);
private:
SceneBVH* m_scene_bvh = nullptr;
std::vector<TriangleObject> m_triangles;
std::vector<TriangleObject*> m_lights;
float m_light_area;
DiscreteSampler* m_light_sampler = nullptr;
EnvmapLoader* m_envmap = nullptr;
Camera* m_camera = nullptr;
SceneSphere m_bounding_sphere;
vec3 m_box_center;
std::unordered_map<int, int> m_primitiveID_to_lightID;
};
|
RNG65536/MCRT
|
src/core/boundedtriangle.h
|
<filename>src/core/boundedtriangle.h
#pragma once
#include <memory>
#include "aabb.h"
#include "triangle.h"
// reference to a triangle that is bounded by a clipping aabb
class BoundedTriangle
{
public:
BoundedTriangle(const std::shared_ptr<Triangle>& triangle, const AABB& aabb);
BoundedTriangle(const std::shared_ptr<BoundedTriangle>& triangle,
const AABB& aabb);
const AABB& clippedBoundingBox() const;
const std::shared_ptr<Triangle>& originalTriangle() const;
bool intersect(Ray& ray, HitInfo& hit_info) const;
bool intersectBound(Ray& ray) const;
// clip the triangle in the min-max slab and return an even tighter bound
AABB clipBoundTight(float min, float max, int axis) const;
private:
const std::shared_ptr<Triangle> m_triangle;
AABB m_clipped_bound; // clipped bound
};
|
Bhaskers-Blu-Org2/DirectML
|
Samples/HelloDirectML/pch.h
|
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#pragma once
#define NOMINMAX
#include <winrt/Windows.Foundation.h>
#include "d3dx12.h" // The D3D12 Helper Library that you downloaded.
#include <DirectML.h> // The DirectML header from the Windows SDK.
#include <dxgi1_4.h>
#include <algorithm>
#include <array>
#include <cstdint>
#include <cassert>
#include <fstream>
#include <iostream>
#include <iterator>
#include <vector>
|
oren12321/linear-algebra
|
include/math/core/allocators.h
|
<filename>include/math/core/allocators.h
#ifndef MATH_CORE_ALLOCATORS_H
#define MATH_CORE_ALLOCATORS_H
#include <cstddef>
#include <cstdlib>
#include <cstdint>
#include <new>
#include <chrono>
#include <utility>
#include <type_traits>
#include <concepts>
#include <memory>
#include <math/core/memory.h>
namespace math::core::allocators {
template <typename T>
concept Not_pointer_or_reference = (!std::is_pointer_v<T> && !std::is_reference_v<T>);
template <class T>
concept Rule_of_five = requires
{
std::is_default_constructible_v<T>;
std::is_copy_constructible_v<T>;
std::is_copy_assignable_v<T>;
std::is_move_constructible_v<T>;
std::is_move_assignable_v<T>;
std::is_destructible_v<T>;
};
template <class T>
concept Allocator = Rule_of_five<T> &&
requires (T t, std::size_t s, math::core::memory::Block b)
{
{t.allocate(s)} -> std::same_as<decltype(b)>;
{t.deallocate(&b)} -> std::same_as<void>;
{t.owns(b)} -> std::same_as<bool>;
};
template <Allocator Primary, Allocator Fallback>
class Fallback_allocator
: private Primary
, private Fallback {
public:
Fallback_allocator() = default;
Fallback_allocator(const Fallback_allocator& other) noexcept
: Primary(other), Fallback(other) {}
Fallback_allocator operator=(const Fallback_allocator& other) noexcept
{
if (this == &other) {
return *this;
}
Primary::operator=(other);
Fallback::operator=(other);
return *this;
}
Fallback_allocator(Fallback_allocator&& other) noexcept
: Primary(std::move(other)), Fallback(std::move(other)) {}
Fallback_allocator& operator=(Fallback_allocator&& other) noexcept
{
if (this == &other) {
return *this;
}
Primary::operator=(std::move(other));
Fallback::operator=(std::move(other));
return *this;
}
virtual ~Fallback_allocator() = default;
[[nodiscard]] math::core::memory::Block allocate(math::core::memory::Block::Size_type s) noexcept
{
math::core::memory::Block b = Primary::allocate(s);
if (b.empty()) {
b = Fallback::allocate(s);
}
return b;
}
void deallocate(math::core::memory::Block* b) noexcept
{
if (Primary::owns(*b)) {
return Primary::deallocate(b);
}
Fallback::deallocate(b);
}
[[nodiscard]] bool owns(math::core::memory::Block b) const noexcept
{
return Primary::owns(b) || Fallback::owns(b);
}
};
class Malloc_allocator {
public:
[[nodiscard]] math::core::memory::Block allocate(math::core::memory::Block::Size_type s) noexcept
{
if (s == 0) {
return { nullptr, s };
}
return { std::malloc(s), s };
}
void deallocate(math::core::memory::Block* b) noexcept
{
std::free(b->p);
b->clear();
}
[[nodiscard]] bool owns(math::core::memory::Block b) const noexcept
{
return b.p;
}
};
template <std::size_t Size>
class Stack_allocator {
static_assert(Size > 1 && Size % 2 == 0);
public:
Stack_allocator() = default;
Stack_allocator(const Stack_allocator& other) noexcept
: p_(d_) {}
Stack_allocator operator=(const Stack_allocator& other) noexcept
{
if (this == &other) {
return *this;
}
p_ = d_;
return *this;
}
Stack_allocator(Stack_allocator&& other) noexcept
: p_(d_)
{
other.p_ = nullptr;
}
Stack_allocator& operator=(Stack_allocator&& other) noexcept
{
if (this == &other) {
return *this;
}
p_ = d_;
other.p_ = nullptr;
return *this;
}
virtual ~Stack_allocator() = default;
[[nodiscard]] math::core::memory::Block allocate(math::core::memory::Block::Size_type s) noexcept
{
auto s1 = align(s);
if (p_ + s1 > d_ + Size || !p_ || s == 0) {
return { nullptr, 0 };
}
math::core::memory::Block b = { p_, s };
p_ += s1;
return b;
}
void deallocate(math::core::memory::Block* b) noexcept
{
if (b->p == p_ - align(b->s)) {
p_ = reinterpret_cast<std::uint8_t*>(b->p);
}
b->clear();
}
[[nodiscard]] bool owns(math::core::memory::Block b) const noexcept
{
return b.p >= d_ && b.p < d_ + Size;
}
private:
std::size_t align(std::size_t s)
{
return s % 2 == 0 ? s : s + 1;
}
std::uint8_t d_[Size] = { 0 };
std::uint8_t* p_{ d_ };
};
template <
Allocator Internal_allocator,
std::size_t Min_size, std::size_t Max_size, std::size_t Max_list_size>
class Free_list_allocator
: private Internal_allocator {
static_assert(Min_size > 1 && Min_size % 2 == 0);
static_assert(Max_size > 1 && Max_size % 2 == 0);
static_assert(Max_list_size > 0);
public:
Free_list_allocator() = default;
Free_list_allocator(const Free_list_allocator& other) noexcept
: Internal_allocator(other), root_(nullptr), list_size_(0) {}
Free_list_allocator operator=(const Free_list_allocator& other) noexcept
{
if (this == &other) {
return *this;
}
Internal_allocator::operator=(other);
root_ = nullptr;
list_size_ = 0;
return *this;
}
Free_list_allocator(Free_list_allocator&& other) noexcept
: Internal_allocator(std::move(other)), root_(other.root_), list_size_(other.list_size_)
{
other.root_ = nullptr;
other.list_size_ = 0;
}
Free_list_allocator& operator=(Free_list_allocator&& other) noexcept
{
if (this == &other) {
return *this;
}
Internal_allocator::operator=(std::move(other));
root_ = other.root_;
list_size_ = other.list_size_;
other.root_ = nullptr;
other.list_size_ = 0;
return *this;
}
// Responsible to release the saved memory blocks
virtual ~Free_list_allocator() noexcept
{
for (std::size_t i = 0; i < list_size_; ++i) {
Node* n = root_;
root_ = root_->next;
math::core::memory::Block b{n, Max_size};
Internal_allocator::deallocate(&b);
}
}
[[nodiscard]] math::core::memory::Block allocate(math::core::memory::Block::Size_type s) noexcept
{
if (s >= Min_size && s <= Max_size && list_size_ > 0) {
math::core::memory::Block b = { root_, s };
root_ = root_->next;
--list_size_;
return b;
}
math::core::memory::Block b = Internal_allocator::allocate((s < Min_size || s > Max_size) ? s : Max_size);
b.s = s;
return b;
}
void deallocate(math::core::memory::Block* b) noexcept
{
if (b->s < Min_size || b->s > Max_size || list_size_ > Max_list_size) {
math::core::memory::Block nb {b->p, Max_size};
b->clear();
return Internal_allocator::deallocate(&nb);
}
auto node = reinterpret_cast<Node*>(b->p);
node->next = root_;
root_ = node;
++list_size_;
b->clear();
}
[[nodiscard]] bool owns(math::core::memory::Block b) const noexcept
{
return (b.s >= Min_size && b.s <= Max_size) || Internal_allocator::owns(b);
}
private:
struct Node {
Node* next{ nullptr };
};
Node* root_{ nullptr };
std::size_t list_size_{ 0 };
};
template <Not_pointer_or_reference T, Allocator Internal_allocator>
class Stl_adapter_allocator
: private Internal_allocator {
public:
using value_type = T;
Stl_adapter_allocator() = default;
Stl_adapter_allocator(const Stl_adapter_allocator& other) noexcept
: Internal_allocator(other) {}
Stl_adapter_allocator operator=(const Stl_adapter_allocator& other) noexcept
{
if (this == &other) {
return *this;
}
Internal_allocator::operator=(other);
return *this;
}
Stl_adapter_allocator(Stl_adapter_allocator&& other) noexcept
: Internal_allocator(std::move(other)) {}
Stl_adapter_allocator& operator=(Stl_adapter_allocator&& other) noexcept
{
if (this == &other) {
return *this;
}
Internal_allocator::operator=(std::move(other));
return *this;
}
virtual ~Stl_adapter_allocator() = default;
template <Not_pointer_or_reference U>
constexpr Stl_adapter_allocator(const Stl_adapter_allocator<U, Internal_allocator>&) noexcept {}
[[nodiscard]] T* allocate(std::size_t n)
{
math::core::memory::Block b = Internal_allocator::allocate(n * sizeof(T));
if (b.empty()) {
throw std::bad_alloc{};
}
return reinterpret_cast<T*>(b.p);
}
void deallocate(T* p, std::size_t n) noexcept
{
math::core::memory::Block b = { reinterpret_cast<void*>(p), n * sizeof(T) };
Internal_allocator::deallocate(&b);
}
};
template <Allocator Internal_allocator, std::size_t Number_of_records>
class Stats_allocator
: private Internal_allocator {
public:
struct Record {
void* record_address{ nullptr };
void* request_address{ nullptr };
std::int64_t amount{ 0 };
std::chrono::time_point<std::chrono::system_clock> time;
Record* next{ nullptr };
};
Stats_allocator() = default;
Stats_allocator(const Stats_allocator& other) noexcept
: Internal_allocator(other)
{
for (Record* r = other.root_; r != nullptr; r = r->next) {
add_record(r->request_address, r->amount - sizeof(Record), r->time);
}
}
Stats_allocator operator=(const Stats_allocator& other) noexcept
{
if (this == &other) {
return *this;
}
Internal_allocator::operator=(other);
for (Record* r = other.root_; r != nullptr; r = r->next) {
add_record(r->request_address, r->amount - sizeof(Record), r->time);
}
return *this;
}
Stats_allocator(Stats_allocator&& other) noexcept
: Internal_allocator(std::move(other)), number_of_records_(other.number_of_records_), total_allocated_(other.total_allocated_), root_(other.root_), tail_(other.tail_)
{
other.number_of_records_ = other.total_allocated_ = 0;
other.root_ = other.tail_ = nullptr;
}
Stats_allocator& operator=(Stats_allocator&& other) noexcept
{
if (this == &other) {
return *this;
}
Internal_allocator::operator=(std::move(other));
number_of_records_ = other.number_of_records_;
total_allocated_ = other.total_allocated_;
root_ = other.root_;
tail_ = other.tail_;
other.number_of_records_ = other.total_allocated_ = 0;
other.root_ = other.tail_ = nullptr;
return *this;
}
virtual ~Stats_allocator() noexcept
{
Record* c = root_;
while (c) {
Record* n = c->next;
math::core::memory::Block b{ c->record_address, sizeof(Record) };
Internal_allocator::deallocate(&b);
c = n;
}
}
[[nodiscard]] math::core::memory::Block allocate(math::core::memory::Block::Size_type s) noexcept
{
math::core::memory::Block b = Internal_allocator::allocate(s);
if (!b.empty()) {
add_record(b.p, static_cast<std::int64_t>(b.s));
}
return b;
}
void deallocate(math::core::memory::Block* b) noexcept
{
math::core::memory::Block bc{ *b };
Internal_allocator::deallocate(b);
if (b->empty()) {
add_record(bc.p, -static_cast<std::int64_t>(bc.s));
}
}
[[nodiscard]] bool owns(math::core::memory::Block b) const noexcept
{
return Internal_allocator::owns(b);
}
const Record* stats_list() const noexcept {
return root_;
}
std::size_t stats_list_size() const noexcept {
return number_of_records_;
}
std::int64_t total_allocated() const noexcept {
return total_allocated_;
}
private:
void add_record(void* p, std::int64_t a, std::chrono::time_point<std::chrono::system_clock> time = std::chrono::system_clock::now()) {
if (number_of_records_ >= Number_of_records) {
tail_->next = root_;
root_ = root_->next;
tail_ = tail_->next;
tail_->next = nullptr;
tail_->request_address = p;
tail_->amount = static_cast<std::int64_t>(sizeof(Record)) + a;
tail_->time = time;
total_allocated_ += tail_->amount;
return;
}
math::core::memory::Block b1 = Internal_allocator::allocate(sizeof(Record));
if (b1.empty()) {
return;
}
if (!root_) {
root_ = reinterpret_cast<Record*>(b1.p);
tail_ = root_;
}
else {
tail_->next = reinterpret_cast<Record*>(b1.p);
tail_ = tail_->next;
}
tail_->record_address = b1.p;
tail_->request_address = p;
tail_->amount = static_cast<std::int64_t>(b1.s) + a;
tail_->time = time;
tail_->next = nullptr;
total_allocated_ += tail_->amount;
++number_of_records_;
}
std::size_t number_of_records_{ 0 };
std::int64_t total_allocated_{ 0 };
Record* root_{ nullptr };
Record* tail_{ nullptr };
};
template <Allocator Internal_allocator, int id = -1>
class Shared_allocator {
public:
[[nodiscard]] math::core::memory::Block allocate(math::core::memory::Block::Size_type s) noexcept
{
return allocator_.allocate(s);
}
void deallocate(math::core::memory::Block* b) noexcept
{
allocator_.deallocate(b);
}
[[nodiscard]] bool owns(math::core::memory::Block b) const noexcept
{
return allocator_.owns(b);
}
private:
inline static Internal_allocator allocator_{};
};
namespace aux {
template <Allocator Internal_allocator, typename T>
class Custom_deleter {
public:
void operator()(T* ptr)
{
math::core::memory::Block b{ ptr, sizeof(T) };
ptr->~T();
allocator_.deallocate(&b);
}
private:
Internal_allocator allocator_{};
};
template <Allocator Internal_allocator, typename T, typename ...Args>
std::unique_ptr<T, Custom_deleter<Internal_allocator, T>> make_unique(Args&&... args)
{
Internal_allocator allocator{};
math::core::memory::Block b = allocator.allocate(sizeof(T));
return std::unique_ptr<T, Custom_deleter<Internal_allocator, T>>(
math::core::memory::aux::construct_at<T>(reinterpret_cast<T*>(b.p), std::forward<Args>(args)...));
}
template <Allocator Internal_allocator, typename T>
std::unique_ptr<T, Custom_deleter<Internal_allocator, T>> make_unique(T* ptr)
{
return std::unique_ptr<T, Custom_deleter<Internal_allocator, T>>(ptr);
}
template <Allocator Internal_allocator, typename T, typename ...Args>
std::shared_ptr<T> make_shared(Args&&... args)
{
Internal_allocator allocator{};
math::core::memory::Block b = allocator.allocate(sizeof(T));
return std::shared_ptr<T>(
math::core::memory::aux::construct_at<T>(reinterpret_cast<T*>(b.p), std::forward<Args>(args)...),
Custom_deleter<Internal_allocator, T>{},
Stl_adapter_allocator<T, Internal_allocator>{});
}
template <Allocator Internal_allocator, typename T>
std::shared_ptr<T> make_shared(T* ptr)
{
return std::shared_ptr<T>(
ptr,
Custom_deleter<Internal_allocator, T>{},
Stl_adapter_allocator<T, Internal_allocator>{});
}
}
}
#endif // MATH_CORE_ALLOCATORS_H
|
oren12321/linear-algebra
|
include/math/core/algorithms.h
|
#ifndef MATH_ALGORITHMS_H
#define MATH_ALGORITHMS_H
#include <type_traits>
#include <cmath>
#include <limits>
#include <memory>
#include <math/core/allocators.h>
namespace math::algorithms {
template <typename T>
concept Arithmetic = std::is_arithmetic_v<T>;
template <Arithmetic T>
bool is_equal(T a, T b, T epsilon = std::sqrt(std::numeric_limits<T>::epsilon()))
{
return std::abs(a - b) <= epsilon;
}
}
namespace math::algorithms::derivatives::backward {
template <typename T>
concept Decimal = std::is_floating_point_v<T>;
template <Decimal F, math::core::allocators::Allocator Internal_allocator>
struct Node {
virtual ~Node() {}
virtual F compute() = 0;
virtual std::shared_ptr<Node<F, Internal_allocator>> backward(std::size_t id) = 0;
};
template <Decimal F, math::core::allocators::Allocator Internal_allocator>
class Const : public Node<F, Internal_allocator> {
public:
Const(F value)
: value_(value) {}
F compute() override
{
return value_;
}
std::shared_ptr<Node<F, Internal_allocator>> backward(std::size_t id) override
{
return math::core::allocators::aux::make_shared<Internal_allocator, Const<F, Internal_allocator>>(F{ 0 });
}
private:
F value_;
};
template <Decimal F, math::core::allocators::Allocator Internal_allocator>
class Var : public Node<F, Internal_allocator> {
public:
Var(std::size_t id, F value)
: id_(id), value_(value) {}
F compute() override
{
return value_;
}
std::shared_ptr<Node<F, Internal_allocator>> backward(std::size_t id) override
{
return id_ == id ?
math::core::allocators::aux::make_shared<Internal_allocator, Const<F, Internal_allocator>>(F{ 1 }) :
math::core::allocators::aux::make_shared<Internal_allocator, Const<F, Internal_allocator>>(F{ 0 });
}
private:
std::size_t id_;
double value_;
};
template <Decimal F, math::core::allocators::Allocator Internal_allocator>
class Add : public Node<F, Internal_allocator> {
public:
Add(const std::shared_ptr<Node<F, Internal_allocator>>& n1, const std::shared_ptr<Node<F, Internal_allocator>>& n2)
: n1_(n1), n2_(n2) {}
F compute() override
{
return n1_->compute() + n2_->compute();
}
std::shared_ptr<Node<F, Internal_allocator>> backward(std::size_t id)
{
return math::core::allocators::aux::make_shared<Internal_allocator, Add<F, Internal_allocator>>(n1_->backward(id), n2_->backward(id));
}
private:
std::shared_ptr<Node<F, Internal_allocator>> n1_;
std::shared_ptr<Node<F, Internal_allocator>> n2_;
};
template <Decimal F, math::core::allocators::Allocator Internal_allocator>
class Mul : public Node<F, Internal_allocator> {
public:
Mul(const std::shared_ptr<Node<F, Internal_allocator>>& n1, const std::shared_ptr<Node<F, Internal_allocator>>& n2)
: n1_(n1), n2_(n2) {}
F compute() override
{
return n1_->compute() * n2_->compute();
}
std::shared_ptr<Node<F, Internal_allocator>> backward(std::size_t id) override
{
return math::core::allocators::aux::make_shared<Internal_allocator, Add<F, Internal_allocator>>(
math::core::allocators::aux::make_shared<Internal_allocator, Mul<F, Internal_allocator>>(n1_->backward(id), n2_),
math::core::allocators::aux::make_shared<Internal_allocator, Mul<F, Internal_allocator>>(n1_, n2_->backward(id)));
}
private:
std::shared_ptr<Node<F, Internal_allocator>> n1_;
std::shared_ptr<Node<F, Internal_allocator>> n2_;
};
}
#endif // MATH_ALGORITHMS_H
|
rhx/sds011udpbridge
|
sds011udpbridge.h
|
<filename>sds011udpbridge.h
//
// sds011udpbridge.h
// sds011udpbridge
//
// Created by <NAME> on 12/1/17.
// Copyright © 2017 <NAME>. All rights reserved.
//
#ifndef sds011udpbridge_h
#define sds011udpbridge_h
#include <stdbool.h>
#include <sys/types.h>
/// default broadcast port
#define SDS011_BROADCAST_PORT 14441
#define SDS011_HEADER 0xAA // header byte
#define SDS011_COMMANDER 0xC0 // commander byte
#define SDS011_TAIL 0xAB // trailing byte
/**
Data sent by the SDS011 sensor over serial at 9600 Baud 8n1
*/
struct SDS011Data
{
uint8_t message_header; // always 0xAA
uint8_t commander_no; // always 0xC0
uint8_t pm25_lo; // DATA1: PM2.5 low byte
uint8_t pm25_hi; // DATA2: PM2.5 high byte
uint8_t pm10_lo; // DATA3: PM10 low byte
uint8_t pm10_hi; // DATA4: PM10 high byte
uint8_t id0; // DATA5: ID byte 1
uint8_t id1; // DATA6: ID byte 2
uint8_t checksum; // sum(DATA1:DATA6)
uint8_t tail; // always 0xAB
};
/**
Serial receive buffer
*/
union SDS011Buffer
{
struct SDS011Data data; // actual data
uint8_t bytes[32]; // buffer space for discarding extra data
};
/**
Check that an SDS011 data packet is correct
@param sds011 pointer to the packet to validate
@return `true` iff valid
*/
static inline bool validate_sds011_data(const struct SDS011Data *sds011)
{
if (sds011->message_header != SDS011_HEADER ||
sds011->commander_no != SDS011_COMMANDER ||
sds011->tail != SDS011_TAIL)
return false;
const uint8_t sum = sds011->pm25_lo + sds011->pm25_hi +
sds011->pm10_lo + sds011->pm10_hi +
sds011->id0 + sds011->id1;
return sds011->checksum == sum;
}
/**
Return the PM2.5 value stored in the packet
@param sds011 pointer to the packet to analyse
@return PM2.5 value
*/
static inline uint16_t pm25(const struct SDS011Data *sds011)
{
return sds011->pm25_lo + (sds011->pm25_hi << 8);
}
/**
Return the PM10 value stored in the packet
@param sds011 pointer to the packet to analyse
@return PM10 value
*/
static inline uint16_t pm10(const struct SDS011Data *sds011)
{
return sds011->pm10_lo + (sds011->pm10_hi << 8);
}
/**
Average data sent via UDP (all fields in network byte order)
*/
struct SDS011Avg
{
uint16_t mean25; // arithmetic average of PM2.5 measurements
uint16_t mean10; // arithmetic average of PM10 measurements
uint16_t variance25; // variance of PM2.5 measurements (nyi)
uint16_t variance10; // variance of PM10 measurements (nyi)
uint16_t measurements; // number of measurements averaged
uint8_t id0; // sensor ID byte 0
uint8_t id1; // sensor ID byte 1
};
#endif /* sds011udpbridge_h */
|
rhx/sds011udpbridge
|
sds011udpbridge.c
|
//
// main.c
// sds011udpbridge
//
// Created by <NAME> on 11/1/17.
// Copyright © 2017 <NAME>. All rights reserved.
//
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <libgen.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <poll.h>
#include <sys/param.h>
#include <sys/termios.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include "sds011udpbridge.h"
#define MAXACCUM 8192 // maximum number of measurements to accumulate
uint32_t accum25 = 0; // pm2.5 values accumulated
uint32_t accum10 = 0; // pm10 values accumulated
uint16_t naccum = 0; // number of values accumulated
uint16_t maxaccum = 60; // number of values to average
uint16_t pm25vals[MAXACCUM]; // individual pm25 values
uint16_t pm10vals[MAXACCUM]; // individual pm10 values
static void usage(const char *cmd)
{
fprintf(stderr, "Usage: %s [-b baud][-d serial_device][-h host][-p port][-n values][-v]\n", basename((char *)cmd));
exit(EXIT_FAILURE);
}
static inline int setup_udp(struct sockaddr_in *dest)
{
int s = socket(PF_INET, SOCK_DGRAM, 0);
if (s <= 0) { perror("broadcast socket"); return s; }
int yes = 1;
if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &yes, sizeof(yes)) == -1)
perror("broadcast setsockopt");
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1)
perror("reuse setsockopt");
memset(dest, 0, sizeof(*dest));
#ifdef BSD
dest->sin_len = sizeof(*dest);
#endif
dest->sin_family = AF_INET;
dest->sin_port = (in_port_t) htons(SDS011_BROADCAST_PORT);
dest->sin_addr.s_addr = htonl(INADDR_BROADCAST);
return s;
}
static inline int broadcast_udp(int s, const void *data, size_t size, struct sockaddr_in *dest)
{
if (sendto(s, data, size, 0, (const struct sockaddr *)dest, sizeof(*dest)) <= 0)
{
perror("broadcast sendto");
return -1;
}
return s;
}
static void dump(const uint8_t *buffer, ssize_t n)
{
int i = 0;
while (i < n)
{
printf("%2.2x", *buffer++ & 0xff);
if (++i % 26 == 0) putchar('\n');
else putchar(' ');
}
if (i % 26) putchar('\n');
}
volatile static bool quit = false;
volatile static bool hangup = false;
static void terminate(int sig)
{
quit = true;
(void) sig;
}
static void trigger_hangup(int sig)
{
hangup = true;
(void) sig;
}
int main(int argc, char * const argv[])
{
const char *device = "/dev/ttyUSB0";
const char *host = NULL;
int verbosity = 0;
speed_t baud = B9600;
uint16_t port = SDS011_BROADCAST_PORT;
int ch;
while ((ch = getopt(argc, argv, "b:d:h:p:v")) != -1) switch(ch)
{
case 'b': baud = atoi(optarg); break;
case 'd': device = optarg; break;
case 'h': host = optarg; break;
case 'n': maxaccum = atoi(optarg); break;
case 'p': port = atoi(optarg); break;
case 'v': verbosity++; break;
case '?':
default: usage(argv[0]);
}
signal(SIGQUIT, terminate);
signal(SIGTERM, terminate);
signal(SIGINT, terminate);
signal(SIGHUP, trigger_hangup);
if (verbosity) printf("Opening '%s'.\n", device);
int fd = open(device, O_RDWR);
if (fd < 0)
{
perror(device);
return EXIT_FAILURE;
}
struct termios tios;
if (verbosity) printf("Setting serial speed to '%d' baud.\n", (int)baud);
if (tcgetattr(fd, &tios) >= 0)
{
cfsetspeed(&tios, baud);
if (tcsetattr(fd, TCSANOW, &tios) < 0)
perror("Cannot set speed");
}
else perror("Cannot get speed");
if (verbosity) printf("Setting up socket for '%s' port %d.\n", host ? host : "broadcast address", (int)port);
struct sockaddr_in dest;
int sock = setup_udp(&dest);
while (!quit)
{
struct pollfd pollfds[1] =
{
{ fd, POLLERR | POLLHUP | POLLIN, 0 },
// { sock, POLLERR | POLLHUP | POLLIN, 0 }
};
int n = poll(pollfds, sizeof(pollfds)/sizeof(pollfds[0]), -1);
if (n <= 0)
{
if (errno != EAGAIN && errno != EINTR)
{
perror("poll");
shutdown(sock, SHUT_RDWR);
close(sock);
close(fd);
exit(EXIT_FAILURE);
}
else if (verbosity)
{
perror("poll");
}
if (hangup)
{
if (verbosity) puts("Sending a break.");
tcdrain(fd);
if (tcsendbreak(fd, 0) != 0)
{
perror("send break");
}
}
continue;
}
else
{
union SDS011Buffer buffer;
const short revents = pollfds[0].revents;
if (revents & POLLERR)
{
perror(device);
quit = true;
break;
}
if (revents & POLLHUP)
{
printf("Hangup received on '%s'.\n", device);
}
if (revents & POLLIN)
{
ssize_t nbytes = read(fd, &buffer, sizeof(buffer));
if (verbosity > 1)
{
printf("Read %ld bytes from '%s'.\n", nbytes, device);
if (verbosity > 2) dump(buffer.bytes, nbytes);
}
if (nbytes <= 0) perror(device);
else if (nbytes != sizeof(struct SDS011Data))
{
fprintf(stderr, "Expected %lu bytes but received %ld.\n", sizeof(struct SDS011Data), nbytes);
}
else if (!validate_sds011_data(&buffer.data))
{
fputs("SDS011 data did not validate.", stderr);
if (verbosity && verbosity <= 2) dump(buffer.bytes, nbytes);
}
else
{
const uint16_t pm25val = pm25(&buffer.data);
const uint16_t pm10val = pm10(&buffer.data);
accum25 += pm25val;
accum10 += pm10val;
pm25vals[naccum] = pm25val;
pm10vals[naccum] = pm10val;
if (verbosity > 1)
printf("PM2.5 = %u, PM10 = %u\n", (int)pm25val, (int)pm10val);
if (++naccum >= maxaccum)
{
const uint16_t mean25 = accum25 / naccum;
const uint16_t mean10 = accum10 / naccum;
uint32_t sd25 = 0;
uint32_t sd10 = 0;
for (int i = 0; i < naccum; i++)
{
const int16_t d25 = (int16_t)pm25vals[i] - (int16_t)mean25;
const int16_t d10 = (int16_t)pm10vals[i] - (int16_t)mean10;
const int32_t sq25 = d25 * d25;
const int32_t sq10 = d10 * d10;
sd25 += sq25;
sd10 += sq10;
}
const uint16_t var25 = sd25 / (naccum-1);
const uint16_t var10 = sd10 / (naccum-1);
struct SDS011Avg packet =
{
htons(mean25), htons(mean10),
htons(var25), htons(var10),
htons(naccum),
buffer.data.id0, buffer.data.id1
};
if (verbosity)
printf("avg2.5 = %g (var: %g), avg10 = %g (var: %g)\n", mean25 / 10.0, var25 / 100.0, mean10 / 10.0, var10 / 100.0);
if (broadcast_udp(sock, &packet, sizeof(packet), &dest) >= 0 ||
naccum >= MAXACCUM)
{
accum25 = 0;
accum10 = 0;
naccum = 0;
}
}
}
}
pollfds[0].revents = 0;
}
}
if (verbosity) puts("Exiting.");
shutdown(sock, SHUT_RDWR);
close(sock);
close(fd);
return EXIT_SUCCESS;
}
|
galenguyer/gay
|
gay.c
|
<reponame>galenguyer/gay<gh_stars>1-10
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct color {
int ansi;
int xterm;
int r;
int g;
int b;
};
void set_ansi(int fg) { printf("\033[%d;%dm", fg, fg - 10); }
void set_8bit(int color) {
// foreground
printf("\033[38;5;%dm", color);
// background
printf("\033[48;5;%dm", color);
}
void set_24bit(int r, int g, int b) {
// foreground
printf("\033[38;2;%d;%d;%dm", r, g, b);
// background
printf("\033[48;2;%d;%d;%dm", r, g, b);
}
void reset_colors() { printf("\033[0m"); }
void print_line(struct color c, int length, int scale) {
for (int s = 0; s < scale; s++) {
printf(" ");
set_ansi(c.ansi);
set_8bit(c.xterm);
set_24bit(c.r, c.g, c.b);
for (int i = 0; i < length * scale; i++) {
// ascii character 219 (https://www.extended-ascii.com/)
printf("█");
}
reset_colors();
printf("\n");
}
}
int main(int argc, char **argv) {
int scale = 1;
if (argc > 1) {
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
puts("gay - v1.0");
puts("by <NAME>");
puts("");
puts("Usage: gay [scale]");
exit(0);
}
if (atoi(argv[i]) > 0) {
scale = atoi(argv[i]);
}
}
}
struct color red = {.ansi = 41, .xterm = 160, .r = 228, .g = 3, .b = 3};
struct color orange = {.ansi = 101, .xterm = 208, .r = 255, .g = 140, .b = 0};
struct color yellow = {.ansi = 103, .xterm = 226, .r = 255, .g = 237, .b = 0};
struct color green = {.ansi = 42, .xterm = 28, .r = 0, .g = 128, .b = 38};
struct color blue = {.ansi = 104, .xterm = 27, .r = 0, .g = 77, .b = 255};
struct color purple = {.ansi = 45, .xterm = 90, .r = 117, .g = 7, .b = 135};
struct color colors[6] = {red, orange, yellow, green, blue, purple};
int colors_t = (int)(sizeof(colors) / sizeof(colors[0]));
puts("");
for (int i = 0; i < colors_t; i++) {
print_line(colors[i], colors_t * 3 - 1, scale);
}
puts("");
return 0;
}
|
saintwithataint/Pro-g-rammingChallenges4
|
Algorithmic/Easy/FizzBuzz/fizzbuzz.c
|
<gh_stars>1-10
#include <stdio.h>
int main(void)
{
int i;
for (i = 1; i <= 100; i++)
{
if (i % 15 == 0)
{
puts("FizzBuzz");
}
else if (i % 3 == 0)
{
puts("Fizz");
}
else if (i % 5 == 0)
{
puts("Buzz");
}
else
{
printf("%d\n", i);
}
}
}
|
saintwithataint/Pro-g-rammingChallenges4
|
Practical/Medium/Producer Consumer/pc.c
|
<filename>Practical/Medium/Producer Consumer/pc.c
#include <stdio.h>
#include <stdlib.h>
int mutex = 1;
int full = 0;
int empty = 10;
int x = 0;
void prod()
{
--mutex, ++full, --empty, x++;
printf("Producer: %d\n", x);
++mutex;
}
void cons()
{
--mutex, --full, ++empty;
printf("Consumer: %d\n", x);
++mutex, x--;
}
int main()
{
int n, i;
printf("\n1. Press 1 for Producer\n2. Press 2 for Consumer\n3. Press 3 for Exit\n");
for (i = 1; i > 0; i++){
printf("\nEnter your choice: ");
scanf("%d", &n);
switch (n)
{
case 1:
if ((mutex == 1) && (empty != 0))
{
prod();
}
else
{
printf("\nBuffer is full\n");
}
break;
case 2:
if ((mutex == 1) && (full != 0))
{
cons();
}
else
{
printf("\nBuffer is empty\n");
}
break;
case 3:
exit(0);
break;
default:
printf("\nInvalid choice\n");
break;
}
}
}
|
larics/uav_ros_control
|
src/control/cvxgen/ldl.c
|
<filename>src/control/cvxgen/ldl.c
/* Produced by CVXGEN, 2021-03-12 04:35:26 -0500. */
/* CVXGEN is Copyright (C) 2006-2017 <NAME>, <EMAIL>. */
/* The code in this file is Copyright (C) 2006-2017 <NAME>. */
/* CVXGEN, or solvers produced by CVXGEN, cannot be used for commercial */
/* applications without prior written permission from <NAME>. */
/* Filename: ldl.c. */
/* Description: Basic test harness for solver.c. */
#include "solver.h"
/* Be sure to place ldl_solve first, so storage schemes are defined by it. */
void ldl_solve(double *target, double *var) {
int i;
/* Find var = (L*diag(work.d)*L') \ target, then unpermute. */
/* Answer goes into var. */
/* Forward substitution. */
/* Include permutation as we retrieve from target. Use v so we can unpermute */
/* later. */
work.v[0] = target[208];
work.v[1] = target[209];
work.v[2] = target[210];
work.v[3] = target[211];
work.v[4] = target[212];
work.v[5] = target[213];
work.v[6] = target[214];
work.v[7] = target[215];
work.v[8] = target[216];
work.v[9] = target[217];
work.v[10] = target[218];
work.v[11] = target[219];
work.v[12] = target[220];
work.v[13] = target[221];
work.v[14] = target[222];
work.v[15] = target[223];
work.v[16] = target[224];
work.v[17] = target[225];
work.v[18] = target[226];
work.v[19] = target[227];
work.v[20] = target[228];
work.v[21] = target[229];
work.v[22] = target[230];
work.v[23] = target[231];
work.v[24] = target[232];
work.v[25] = target[233];
work.v[26] = target[234];
work.v[27] = target[235];
work.v[28] = target[236];
work.v[29] = target[237];
work.v[30] = target[238];
work.v[31] = target[239];
work.v[32] = target[240];
work.v[33] = target[241];
work.v[34] = target[242];
work.v[35] = target[243];
work.v[36] = target[244];
work.v[37] = target[245];
work.v[38] = target[246];
work.v[39] = target[247];
work.v[40] = target[248];
work.v[41] = target[249];
work.v[42] = target[250];
work.v[43] = target[251];
work.v[44] = target[252];
work.v[45] = target[253];
work.v[46] = target[254];
work.v[47] = target[255];
work.v[48] = target[256];
work.v[49] = target[257];
work.v[50] = target[258];
work.v[51] = target[259];
work.v[52] = target[260];
work.v[53] = target[261];
work.v[54] = target[262];
work.v[55] = target[263];
work.v[56] = target[264];
work.v[57] = target[265];
work.v[58] = target[266];
work.v[59] = target[267];
work.v[60] = target[268];
work.v[61] = target[269];
work.v[62] = target[270];
work.v[63] = target[271];
work.v[64] = target[272];
work.v[65] = target[273];
work.v[66] = target[274];
work.v[67] = target[275];
work.v[68] = target[276];
work.v[69] = target[277];
work.v[70] = target[278];
work.v[71] = target[279];
work.v[72] = target[280];
work.v[73] = target[281];
work.v[74] = target[282];
work.v[75] = target[283];
work.v[76] = target[284];
work.v[77] = target[285];
work.v[78] = target[286];
work.v[79] = target[287];
work.v[80] = target[288];
work.v[81] = target[289];
work.v[82] = target[290];
work.v[83] = target[291];
work.v[84] = target[292];
work.v[85] = target[293];
work.v[86] = target[294];
work.v[87] = target[295];
work.v[88] = target[296];
work.v[89] = target[297];
work.v[90] = target[298];
work.v[91] = target[299];
work.v[92] = target[300];
work.v[93] = target[301];
work.v[94] = target[302];
work.v[95] = target[303];
work.v[96] = target[304];
work.v[97] = target[305];
work.v[98] = target[306];
work.v[99] = target[307];
work.v[100] = target[308];
work.v[101] = target[309];
work.v[102] = target[310];
work.v[103] = target[311];
work.v[104] = target[312];
work.v[105] = target[313];
work.v[106] = target[314];
work.v[107] = target[315];
work.v[108] = target[316];
work.v[109] = target[317];
work.v[110] = target[318];
work.v[111] = target[319];
work.v[112] = target[320];
work.v[113] = target[321];
work.v[114] = target[322];
work.v[115] = target[323];
work.v[116] = target[324];
work.v[117] = target[325];
work.v[118] = target[326];
work.v[119] = target[327];
work.v[120] = target[328];
work.v[121] = target[329];
work.v[122] = target[330];
work.v[123] = target[331];
work.v[124] = target[332];
work.v[125] = target[333];
work.v[126] = target[334];
work.v[127] = target[335];
work.v[128] = target[336];
work.v[129] = target[337];
work.v[130] = target[338];
work.v[131] = target[339];
work.v[132] = target[340];
work.v[133] = target[341];
work.v[134] = target[342];
work.v[135] = target[343];
work.v[136] = target[344];
work.v[137] = target[345];
work.v[138] = target[346];
work.v[139] = target[347];
work.v[140] = target[348];
work.v[141] = target[349];
work.v[142] = target[350];
work.v[143] = target[351];
work.v[144] = target[352];
work.v[145] = target[353];
work.v[146] = target[354];
work.v[147] = target[355];
work.v[148] = target[356];
work.v[149] = target[357];
work.v[150] = target[358];
work.v[151] = target[359];
work.v[152] = target[360];
work.v[153] = target[361];
work.v[154] = target[362];
work.v[155] = target[363];
work.v[156] = target[364];
work.v[157] = target[365];
work.v[158] = target[366];
work.v[159] = target[367];
work.v[160] = target[368];
work.v[161] = target[369];
work.v[162] = target[370];
work.v[163] = target[371];
work.v[164] = target[372];
work.v[165] = target[373];
work.v[166] = target[374];
work.v[167] = target[375];
work.v[168] = target[376];
work.v[169] = target[377];
work.v[170] = target[378];
work.v[171] = target[379];
work.v[172] = target[380];
work.v[173] = target[381];
work.v[174] = target[382];
work.v[175] = target[383];
work.v[176] = target[384];
work.v[177] = target[385];
work.v[178] = target[386];
work.v[179] = target[387];
work.v[180] = target[388];
work.v[181] = target[389];
work.v[182] = target[390];
work.v[183] = target[391];
work.v[184] = target[392];
work.v[185] = target[393];
work.v[186] = target[394];
work.v[187] = target[395];
work.v[188] = target[396];
work.v[189] = target[397];
work.v[190] = target[398];
work.v[191] = target[399];
work.v[192] = target[400];
work.v[193] = target[401];
work.v[194] = target[402];
work.v[195] = target[403];
work.v[196] = target[404];
work.v[197] = target[405];
work.v[198] = target[406];
work.v[199] = target[407];
work.v[200] = target[408];
work.v[201] = target[409];
work.v[202] = target[410];
work.v[203] = target[411];
work.v[204] = target[412];
work.v[205] = target[413];
work.v[206] = target[414];
work.v[207] = target[415];
work.v[208] = target[416];
work.v[209] = target[417];
work.v[210] = target[418];
work.v[211] = target[419];
work.v[212] = target[420];
work.v[213] = target[421];
work.v[214] = target[422];
work.v[215] = target[423];
work.v[216] = target[424];
work.v[217] = target[425];
work.v[218] = target[426];
work.v[219] = target[427];
work.v[220] = target[428];
work.v[221] = target[429];
work.v[222] = target[430];
work.v[223] = target[431];
work.v[224] = target[432];
work.v[225] = target[433];
work.v[226] = target[434];
work.v[227] = target[435];
work.v[228] = target[436];
work.v[229] = target[437];
work.v[230] = target[438];
work.v[231] = target[439];
work.v[232] = target[440];
work.v[233] = target[441];
work.v[234] = target[442];
work.v[235] = target[443];
work.v[236] = target[444];
work.v[237] = target[445];
work.v[238] = target[446];
work.v[239] = target[447];
work.v[240] = target[448];
work.v[241] = target[449];
work.v[242] = target[450];
work.v[243] = target[451];
work.v[244] = target[452];
work.v[245] = target[453];
work.v[246] = target[454];
work.v[247] = target[455];
work.v[248] = target[456];
work.v[249] = target[457];
work.v[250] = target[458];
work.v[251] = target[459];
work.v[252] = target[460];
work.v[253] = target[461];
work.v[254] = target[462];
work.v[255] = target[463];
work.v[256] = target[464];
work.v[257] = target[465];
work.v[258] = target[466];
work.v[259] = target[467];
work.v[260] = target[468];
work.v[261] = target[469];
work.v[262] = target[470];
work.v[263] = target[471];
work.v[264] = target[472];
work.v[265] = target[473];
work.v[266] = target[474];
work.v[267] = target[475];
work.v[268] = target[476];
work.v[269] = target[477];
work.v[270] = target[478];
work.v[271] = target[479];
work.v[272] = target[480];
work.v[273] = target[481];
work.v[274] = target[482];
work.v[275] = target[483];
work.v[276] = target[484];
work.v[277] = target[485];
work.v[278] = target[486];
work.v[279] = target[487];
work.v[280] = target[488];
work.v[281] = target[489];
work.v[282] = target[490];
work.v[283] = target[491];
work.v[284] = target[492];
work.v[285] = target[493];
work.v[286] = target[494];
work.v[287] = target[495];
work.v[288] = target[496];
work.v[289] = target[497];
work.v[290] = target[498];
work.v[291] = target[499];
work.v[292] = target[500];
work.v[293] = target[501];
work.v[294] = target[502];
work.v[295] = target[503];
work.v[296] = target[504];
work.v[297] = target[505];
work.v[298] = target[506];
work.v[299] = target[507];
work.v[300] = target[508];
work.v[301] = target[509];
work.v[302] = target[510];
work.v[303] = target[511];
work.v[304] = target[512];
work.v[305] = target[513];
work.v[306] = target[514];
work.v[307] = target[515];
work.v[308] = target[516];
work.v[309] = target[517];
work.v[310] = target[518];
work.v[311] = target[519];
work.v[312] = target[832];
work.v[313] = target[833];
work.v[314] = target[130]-work.L[0]*work.v[312];
work.v[315] = target[205];
work.v[316] = target[520]-work.L[1]*work.v[0];
work.v[317] = target[0]-work.L[2]*work.v[316];
work.v[318] = target[521]-work.L[3]*work.v[1]-work.L[4]*work.v[317];
work.v[319] = target[522]-work.L[5]*work.v[2]-work.L[6]*work.v[317]-work.L[7]*work.v[318];
work.v[320] = target[523]-work.L[8]*work.v[3];
work.v[321] = target[1]-work.L[9]*work.v[320];
work.v[322] = target[524]-work.L[10]*work.v[4]-work.L[11]*work.v[321];
work.v[323] = target[525]-work.L[12]*work.v[5]-work.L[13]*work.v[321]-work.L[14]*work.v[322];
work.v[324] = target[526]-work.L[15]*work.v[6];
work.v[325] = target[2]-work.L[16]*work.v[324];
work.v[326] = target[527]-work.L[17]*work.v[7]-work.L[18]*work.v[325];
work.v[327] = target[528]-work.L[19]*work.v[8]-work.L[20]*work.v[325]-work.L[21]*work.v[326];
work.v[328] = target[529]-work.L[22]*work.v[9];
work.v[329] = target[3]-work.L[23]*work.v[328];
work.v[330] = target[530]-work.L[24]*work.v[10]-work.L[25]*work.v[329];
work.v[331] = target[531]-work.L[26]*work.v[11]-work.L[27]*work.v[329]-work.L[28]*work.v[330];
work.v[332] = target[532]-work.L[29]*work.v[12];
work.v[333] = target[4]-work.L[30]*work.v[332];
work.v[334] = target[533]-work.L[31]*work.v[13]-work.L[32]*work.v[333];
work.v[335] = target[534]-work.L[33]*work.v[14]-work.L[34]*work.v[333]-work.L[35]*work.v[334];
work.v[336] = target[535]-work.L[36]*work.v[15];
work.v[337] = target[5]-work.L[37]*work.v[336];
work.v[338] = target[536]-work.L[38]*work.v[16]-work.L[39]*work.v[337];
work.v[339] = target[537]-work.L[40]*work.v[17]-work.L[41]*work.v[337]-work.L[42]*work.v[338];
work.v[340] = target[538]-work.L[43]*work.v[18];
work.v[341] = target[6]-work.L[44]*work.v[340];
work.v[342] = target[539]-work.L[45]*work.v[19]-work.L[46]*work.v[341];
work.v[343] = target[540]-work.L[47]*work.v[20]-work.L[48]*work.v[341]-work.L[49]*work.v[342];
work.v[344] = target[541]-work.L[50]*work.v[21];
work.v[345] = target[7]-work.L[51]*work.v[344];
work.v[346] = target[542]-work.L[52]*work.v[22]-work.L[53]*work.v[345];
work.v[347] = target[543]-work.L[54]*work.v[23]-work.L[55]*work.v[345]-work.L[56]*work.v[346];
work.v[348] = target[544]-work.L[57]*work.v[24];
work.v[349] = target[8]-work.L[58]*work.v[348];
work.v[350] = target[545]-work.L[59]*work.v[25]-work.L[60]*work.v[349];
work.v[351] = target[546]-work.L[61]*work.v[26]-work.L[62]*work.v[349]-work.L[63]*work.v[350];
work.v[352] = target[547]-work.L[64]*work.v[27];
work.v[353] = target[9]-work.L[65]*work.v[352];
work.v[354] = target[548]-work.L[66]*work.v[28]-work.L[67]*work.v[353];
work.v[355] = target[549]-work.L[68]*work.v[29]-work.L[69]*work.v[353]-work.L[70]*work.v[354];
work.v[356] = target[550]-work.L[71]*work.v[30];
work.v[357] = target[10]-work.L[72]*work.v[356];
work.v[358] = target[551]-work.L[73]*work.v[31]-work.L[74]*work.v[357];
work.v[359] = target[552]-work.L[75]*work.v[32]-work.L[76]*work.v[357]-work.L[77]*work.v[358];
work.v[360] = target[553]-work.L[78]*work.v[33];
work.v[361] = target[11]-work.L[79]*work.v[360];
work.v[362] = target[554]-work.L[80]*work.v[34]-work.L[81]*work.v[361];
work.v[363] = target[555]-work.L[82]*work.v[35]-work.L[83]*work.v[361]-work.L[84]*work.v[362];
work.v[364] = target[556]-work.L[85]*work.v[36];
work.v[365] = target[12]-work.L[86]*work.v[364];
work.v[366] = target[557]-work.L[87]*work.v[37]-work.L[88]*work.v[365];
work.v[367] = target[558]-work.L[89]*work.v[38]-work.L[90]*work.v[365]-work.L[91]*work.v[366];
work.v[368] = target[559]-work.L[92]*work.v[39];
work.v[369] = target[13]-work.L[93]*work.v[368];
work.v[370] = target[560]-work.L[94]*work.v[40]-work.L[95]*work.v[369];
work.v[371] = target[561]-work.L[96]*work.v[41]-work.L[97]*work.v[369]-work.L[98]*work.v[370];
work.v[372] = target[562]-work.L[99]*work.v[42];
work.v[373] = target[14]-work.L[100]*work.v[372];
work.v[374] = target[563]-work.L[101]*work.v[43]-work.L[102]*work.v[373];
work.v[375] = target[564]-work.L[103]*work.v[44]-work.L[104]*work.v[373]-work.L[105]*work.v[374];
work.v[376] = target[565]-work.L[106]*work.v[45];
work.v[377] = target[15]-work.L[107]*work.v[376];
work.v[378] = target[566]-work.L[108]*work.v[46]-work.L[109]*work.v[377];
work.v[379] = target[567]-work.L[110]*work.v[47]-work.L[111]*work.v[377]-work.L[112]*work.v[378];
work.v[380] = target[568]-work.L[113]*work.v[48];
work.v[381] = target[16]-work.L[114]*work.v[380];
work.v[382] = target[569]-work.L[115]*work.v[49]-work.L[116]*work.v[381];
work.v[383] = target[570]-work.L[117]*work.v[50]-work.L[118]*work.v[381]-work.L[119]*work.v[382];
work.v[384] = target[571]-work.L[120]*work.v[51];
work.v[385] = target[17]-work.L[121]*work.v[384];
work.v[386] = target[572]-work.L[122]*work.v[52]-work.L[123]*work.v[385];
work.v[387] = target[573]-work.L[124]*work.v[53]-work.L[125]*work.v[385]-work.L[126]*work.v[386];
work.v[388] = target[574]-work.L[127]*work.v[54];
work.v[389] = target[18]-work.L[128]*work.v[388];
work.v[390] = target[575]-work.L[129]*work.v[55]-work.L[130]*work.v[389];
work.v[391] = target[576]-work.L[131]*work.v[56]-work.L[132]*work.v[389]-work.L[133]*work.v[390];
work.v[392] = target[577]-work.L[134]*work.v[57];
work.v[393] = target[19]-work.L[135]*work.v[392];
work.v[394] = target[578]-work.L[136]*work.v[58]-work.L[137]*work.v[393];
work.v[395] = target[579]-work.L[138]*work.v[59]-work.L[139]*work.v[393]-work.L[140]*work.v[394];
work.v[396] = target[580]-work.L[141]*work.v[60];
work.v[397] = target[20]-work.L[142]*work.v[396];
work.v[398] = target[581]-work.L[143]*work.v[61]-work.L[144]*work.v[397];
work.v[399] = target[582]-work.L[145]*work.v[62]-work.L[146]*work.v[397]-work.L[147]*work.v[398];
work.v[400] = target[583]-work.L[148]*work.v[63];
work.v[401] = target[21]-work.L[149]*work.v[400];
work.v[402] = target[584]-work.L[150]*work.v[64]-work.L[151]*work.v[401];
work.v[403] = target[585]-work.L[152]*work.v[65]-work.L[153]*work.v[401]-work.L[154]*work.v[402];
work.v[404] = target[586]-work.L[155]*work.v[66];
work.v[405] = target[22]-work.L[156]*work.v[404];
work.v[406] = target[587]-work.L[157]*work.v[67]-work.L[158]*work.v[405];
work.v[407] = target[588]-work.L[159]*work.v[68]-work.L[160]*work.v[405]-work.L[161]*work.v[406];
work.v[408] = target[589]-work.L[162]*work.v[69];
work.v[409] = target[23]-work.L[163]*work.v[408];
work.v[410] = target[590]-work.L[164]*work.v[70]-work.L[165]*work.v[409];
work.v[411] = target[591]-work.L[166]*work.v[71]-work.L[167]*work.v[409]-work.L[168]*work.v[410];
work.v[412] = target[592]-work.L[169]*work.v[72];
work.v[413] = target[24]-work.L[170]*work.v[412];
work.v[414] = target[593]-work.L[171]*work.v[73]-work.L[172]*work.v[413];
work.v[415] = target[594]-work.L[173]*work.v[74]-work.L[174]*work.v[413]-work.L[175]*work.v[414];
work.v[416] = target[595]-work.L[176]*work.v[75];
work.v[417] = target[25]-work.L[177]*work.v[416];
work.v[418] = target[596]-work.L[178]*work.v[76]-work.L[179]*work.v[417];
work.v[419] = target[597]-work.L[180]*work.v[77]-work.L[181]*work.v[417]-work.L[182]*work.v[418];
work.v[420] = target[598]-work.L[183]*work.v[78];
work.v[421] = target[26]-work.L[184]*work.v[420];
work.v[422] = target[599]-work.L[185]*work.v[79]-work.L[186]*work.v[421];
work.v[423] = target[600]-work.L[187]*work.v[80]-work.L[188]*work.v[421]-work.L[189]*work.v[422];
work.v[424] = target[601]-work.L[190]*work.v[81];
work.v[425] = target[27]-work.L[191]*work.v[424];
work.v[426] = target[602]-work.L[192]*work.v[82]-work.L[193]*work.v[425];
work.v[427] = target[603]-work.L[194]*work.v[83]-work.L[195]*work.v[425]-work.L[196]*work.v[426];
work.v[428] = target[604]-work.L[197]*work.v[84];
work.v[429] = target[28]-work.L[198]*work.v[428];
work.v[430] = target[605]-work.L[199]*work.v[85]-work.L[200]*work.v[429];
work.v[431] = target[606]-work.L[201]*work.v[86]-work.L[202]*work.v[429]-work.L[203]*work.v[430];
work.v[432] = target[607]-work.L[204]*work.v[87];
work.v[433] = target[29]-work.L[205]*work.v[432];
work.v[434] = target[608]-work.L[206]*work.v[88]-work.L[207]*work.v[433];
work.v[435] = target[609]-work.L[208]*work.v[89]-work.L[209]*work.v[433]-work.L[210]*work.v[434];
work.v[436] = target[610]-work.L[211]*work.v[90];
work.v[437] = target[30]-work.L[212]*work.v[436];
work.v[438] = target[611]-work.L[213]*work.v[91]-work.L[214]*work.v[437];
work.v[439] = target[612]-work.L[215]*work.v[92]-work.L[216]*work.v[437]-work.L[217]*work.v[438];
work.v[440] = target[613]-work.L[218]*work.v[93];
work.v[441] = target[31]-work.L[219]*work.v[440];
work.v[442] = target[614]-work.L[220]*work.v[94]-work.L[221]*work.v[441];
work.v[443] = target[615]-work.L[222]*work.v[95]-work.L[223]*work.v[441]-work.L[224]*work.v[442];
work.v[444] = target[616]-work.L[225]*work.v[96];
work.v[445] = target[32]-work.L[226]*work.v[444];
work.v[446] = target[617]-work.L[227]*work.v[97]-work.L[228]*work.v[445];
work.v[447] = target[618]-work.L[229]*work.v[98]-work.L[230]*work.v[445]-work.L[231]*work.v[446];
work.v[448] = target[619]-work.L[232]*work.v[99];
work.v[449] = target[33]-work.L[233]*work.v[448];
work.v[450] = target[620]-work.L[234]*work.v[100]-work.L[235]*work.v[449];
work.v[451] = target[621]-work.L[236]*work.v[101]-work.L[237]*work.v[449]-work.L[238]*work.v[450];
work.v[452] = target[622]-work.L[239]*work.v[102];
work.v[453] = target[34]-work.L[240]*work.v[452];
work.v[454] = target[623]-work.L[241]*work.v[103]-work.L[242]*work.v[453];
work.v[455] = target[624]-work.L[243]*work.v[104]-work.L[244]*work.v[453]-work.L[245]*work.v[454];
work.v[456] = target[625]-work.L[246]*work.v[105];
work.v[457] = target[35]-work.L[247]*work.v[456];
work.v[458] = target[626]-work.L[248]*work.v[106]-work.L[249]*work.v[457];
work.v[459] = target[627]-work.L[250]*work.v[107]-work.L[251]*work.v[457]-work.L[252]*work.v[458];
work.v[460] = target[628]-work.L[253]*work.v[108];
work.v[461] = target[36]-work.L[254]*work.v[460];
work.v[462] = target[629]-work.L[255]*work.v[109]-work.L[256]*work.v[461];
work.v[463] = target[630]-work.L[257]*work.v[110]-work.L[258]*work.v[461]-work.L[259]*work.v[462];
work.v[464] = target[631]-work.L[260]*work.v[111];
work.v[465] = target[37]-work.L[261]*work.v[464];
work.v[466] = target[632]-work.L[262]*work.v[112]-work.L[263]*work.v[465];
work.v[467] = target[633]-work.L[264]*work.v[113]-work.L[265]*work.v[465]-work.L[266]*work.v[466];
work.v[468] = target[634]-work.L[267]*work.v[114];
work.v[469] = target[38]-work.L[268]*work.v[468];
work.v[470] = target[635]-work.L[269]*work.v[115]-work.L[270]*work.v[469];
work.v[471] = target[636]-work.L[271]*work.v[116]-work.L[272]*work.v[469]-work.L[273]*work.v[470];
work.v[472] = target[637]-work.L[274]*work.v[117];
work.v[473] = target[39]-work.L[275]*work.v[472];
work.v[474] = target[638]-work.L[276]*work.v[118]-work.L[277]*work.v[473];
work.v[475] = target[639]-work.L[278]*work.v[119]-work.L[279]*work.v[473]-work.L[280]*work.v[474];
work.v[476] = target[640]-work.L[281]*work.v[120];
work.v[477] = target[40]-work.L[282]*work.v[476];
work.v[478] = target[641]-work.L[283]*work.v[121]-work.L[284]*work.v[477];
work.v[479] = target[642]-work.L[285]*work.v[122]-work.L[286]*work.v[477]-work.L[287]*work.v[478];
work.v[480] = target[643]-work.L[288]*work.v[123];
work.v[481] = target[41]-work.L[289]*work.v[480];
work.v[482] = target[644]-work.L[290]*work.v[124]-work.L[291]*work.v[481];
work.v[483] = target[645]-work.L[292]*work.v[125]-work.L[293]*work.v[481]-work.L[294]*work.v[482];
work.v[484] = target[646]-work.L[295]*work.v[126];
work.v[485] = target[42]-work.L[296]*work.v[484];
work.v[486] = target[647]-work.L[297]*work.v[127]-work.L[298]*work.v[485];
work.v[487] = target[648]-work.L[299]*work.v[128]-work.L[300]*work.v[485]-work.L[301]*work.v[486];
work.v[488] = target[649]-work.L[302]*work.v[129];
work.v[489] = target[43]-work.L[303]*work.v[488];
work.v[490] = target[650]-work.L[304]*work.v[130]-work.L[305]*work.v[489];
work.v[491] = target[651]-work.L[306]*work.v[131]-work.L[307]*work.v[489]-work.L[308]*work.v[490];
work.v[492] = target[652]-work.L[309]*work.v[132];
work.v[493] = target[44]-work.L[310]*work.v[492];
work.v[494] = target[653]-work.L[311]*work.v[133]-work.L[312]*work.v[493];
work.v[495] = target[654]-work.L[313]*work.v[134]-work.L[314]*work.v[493]-work.L[315]*work.v[494];
work.v[496] = target[655]-work.L[316]*work.v[135];
work.v[497] = target[45]-work.L[317]*work.v[496];
work.v[498] = target[656]-work.L[318]*work.v[136]-work.L[319]*work.v[497];
work.v[499] = target[657]-work.L[320]*work.v[137]-work.L[321]*work.v[497]-work.L[322]*work.v[498];
work.v[500] = target[658]-work.L[323]*work.v[138];
work.v[501] = target[46]-work.L[324]*work.v[500];
work.v[502] = target[659]-work.L[325]*work.v[139]-work.L[326]*work.v[501];
work.v[503] = target[660]-work.L[327]*work.v[140]-work.L[328]*work.v[501]-work.L[329]*work.v[502];
work.v[504] = target[661]-work.L[330]*work.v[141];
work.v[505] = target[47]-work.L[331]*work.v[504];
work.v[506] = target[662]-work.L[332]*work.v[142]-work.L[333]*work.v[505];
work.v[507] = target[663]-work.L[334]*work.v[143]-work.L[335]*work.v[505]-work.L[336]*work.v[506];
work.v[508] = target[664]-work.L[337]*work.v[144];
work.v[509] = target[48]-work.L[338]*work.v[508];
work.v[510] = target[665]-work.L[339]*work.v[145]-work.L[340]*work.v[509];
work.v[511] = target[666]-work.L[341]*work.v[146]-work.L[342]*work.v[509]-work.L[343]*work.v[510];
work.v[512] = target[667]-work.L[344]*work.v[147];
work.v[513] = target[49]-work.L[345]*work.v[512];
work.v[514] = target[668]-work.L[346]*work.v[148]-work.L[347]*work.v[513];
work.v[515] = target[669]-work.L[348]*work.v[149]-work.L[349]*work.v[513]-work.L[350]*work.v[514];
work.v[516] = target[670]-work.L[351]*work.v[150];
work.v[517] = target[50]-work.L[352]*work.v[516];
work.v[518] = target[671]-work.L[353]*work.v[151]-work.L[354]*work.v[517];
work.v[519] = target[672]-work.L[355]*work.v[152]-work.L[356]*work.v[517]-work.L[357]*work.v[518];
work.v[520] = target[673]-work.L[358]*work.v[153];
work.v[521] = target[51]-work.L[359]*work.v[520];
work.v[522] = target[674]-work.L[360]*work.v[154]-work.L[361]*work.v[521];
work.v[523] = target[675]-work.L[362]*work.v[155]-work.L[363]*work.v[521]-work.L[364]*work.v[522];
work.v[524] = target[676]-work.L[365]*work.v[156];
work.v[525] = target[52]-work.L[366]*work.v[524];
work.v[526] = target[677]-work.L[367]*work.v[157]-work.L[368]*work.v[525];
work.v[527] = target[678]-work.L[369]*work.v[158]-work.L[370]*work.v[525]-work.L[371]*work.v[526];
work.v[528] = target[679]-work.L[372]*work.v[159];
work.v[529] = target[53]-work.L[373]*work.v[528];
work.v[530] = target[680]-work.L[374]*work.v[160]-work.L[375]*work.v[529];
work.v[531] = target[681]-work.L[376]*work.v[161]-work.L[377]*work.v[529]-work.L[378]*work.v[530];
work.v[532] = target[682]-work.L[379]*work.v[162];
work.v[533] = target[54]-work.L[380]*work.v[532];
work.v[534] = target[683]-work.L[381]*work.v[163]-work.L[382]*work.v[533];
work.v[535] = target[684]-work.L[383]*work.v[164]-work.L[384]*work.v[533]-work.L[385]*work.v[534];
work.v[536] = target[685]-work.L[386]*work.v[165];
work.v[537] = target[55]-work.L[387]*work.v[536];
work.v[538] = target[686]-work.L[388]*work.v[166]-work.L[389]*work.v[537];
work.v[539] = target[687]-work.L[390]*work.v[167]-work.L[391]*work.v[537]-work.L[392]*work.v[538];
work.v[540] = target[688]-work.L[393]*work.v[168];
work.v[541] = target[56]-work.L[394]*work.v[540];
work.v[542] = target[689]-work.L[395]*work.v[169]-work.L[396]*work.v[541];
work.v[543] = target[690]-work.L[397]*work.v[170]-work.L[398]*work.v[541]-work.L[399]*work.v[542];
work.v[544] = target[691]-work.L[400]*work.v[171];
work.v[545] = target[57]-work.L[401]*work.v[544];
work.v[546] = target[692]-work.L[402]*work.v[172]-work.L[403]*work.v[545];
work.v[547] = target[693]-work.L[404]*work.v[173]-work.L[405]*work.v[545]-work.L[406]*work.v[546];
work.v[548] = target[694]-work.L[407]*work.v[174];
work.v[549] = target[58]-work.L[408]*work.v[548];
work.v[550] = target[695]-work.L[409]*work.v[175]-work.L[410]*work.v[549];
work.v[551] = target[696]-work.L[411]*work.v[176]-work.L[412]*work.v[549]-work.L[413]*work.v[550];
work.v[552] = target[697]-work.L[414]*work.v[177];
work.v[553] = target[59]-work.L[415]*work.v[552];
work.v[554] = target[698]-work.L[416]*work.v[178]-work.L[417]*work.v[553];
work.v[555] = target[699]-work.L[418]*work.v[179]-work.L[419]*work.v[553]-work.L[420]*work.v[554];
work.v[556] = target[700]-work.L[421]*work.v[180];
work.v[557] = target[60]-work.L[422]*work.v[556];
work.v[558] = target[701]-work.L[423]*work.v[181]-work.L[424]*work.v[557];
work.v[559] = target[702]-work.L[425]*work.v[182]-work.L[426]*work.v[557]-work.L[427]*work.v[558];
work.v[560] = target[703]-work.L[428]*work.v[183];
work.v[561] = target[61]-work.L[429]*work.v[560];
work.v[562] = target[704]-work.L[430]*work.v[184]-work.L[431]*work.v[561];
work.v[563] = target[705]-work.L[432]*work.v[185]-work.L[433]*work.v[561]-work.L[434]*work.v[562];
work.v[564] = target[706]-work.L[435]*work.v[186];
work.v[565] = target[62]-work.L[436]*work.v[564];
work.v[566] = target[707]-work.L[437]*work.v[187]-work.L[438]*work.v[565];
work.v[567] = target[708]-work.L[439]*work.v[188]-work.L[440]*work.v[565]-work.L[441]*work.v[566];
work.v[568] = target[709]-work.L[442]*work.v[189];
work.v[569] = target[63]-work.L[443]*work.v[568];
work.v[570] = target[710]-work.L[444]*work.v[190]-work.L[445]*work.v[569];
work.v[571] = target[711]-work.L[446]*work.v[191]-work.L[447]*work.v[569]-work.L[448]*work.v[570];
work.v[572] = target[712]-work.L[449]*work.v[192];
work.v[573] = target[64]-work.L[450]*work.v[572];
work.v[574] = target[713]-work.L[451]*work.v[193]-work.L[452]*work.v[573];
work.v[575] = target[714]-work.L[453]*work.v[194]-work.L[454]*work.v[573]-work.L[455]*work.v[574];
work.v[576] = target[715]-work.L[456]*work.v[195];
work.v[577] = target[65]-work.L[457]*work.v[576];
work.v[578] = target[716]-work.L[458]*work.v[196]-work.L[459]*work.v[577];
work.v[579] = target[717]-work.L[460]*work.v[197]-work.L[461]*work.v[577]-work.L[462]*work.v[578];
work.v[580] = target[718]-work.L[463]*work.v[198];
work.v[581] = target[66]-work.L[464]*work.v[580];
work.v[582] = target[719]-work.L[465]*work.v[199]-work.L[466]*work.v[581];
work.v[583] = target[720]-work.L[467]*work.v[200]-work.L[468]*work.v[581]-work.L[469]*work.v[582];
work.v[584] = target[721]-work.L[470]*work.v[201];
work.v[585] = target[67]-work.L[471]*work.v[584];
work.v[586] = target[722]-work.L[472]*work.v[202]-work.L[473]*work.v[585];
work.v[587] = target[723]-work.L[474]*work.v[203]-work.L[475]*work.v[585]-work.L[476]*work.v[586];
work.v[588] = target[724]-work.L[477]*work.v[204];
work.v[589] = target[68]-work.L[478]*work.v[588];
work.v[590] = target[725]-work.L[479]*work.v[205]-work.L[480]*work.v[589];
work.v[591] = target[726]-work.L[481]*work.v[206]-work.L[482]*work.v[589]-work.L[483]*work.v[590];
work.v[592] = target[727]-work.L[484]*work.v[207];
work.v[593] = target[69]-work.L[485]*work.v[592];
work.v[594] = target[728]-work.L[486]*work.v[208]-work.L[487]*work.v[593];
work.v[595] = target[729]-work.L[488]*work.v[209]-work.L[489]*work.v[593]-work.L[490]*work.v[594];
work.v[596] = target[730]-work.L[491]*work.v[210];
work.v[597] = target[70]-work.L[492]*work.v[596];
work.v[598] = target[731]-work.L[493]*work.v[211]-work.L[494]*work.v[597];
work.v[599] = target[732]-work.L[495]*work.v[212]-work.L[496]*work.v[597]-work.L[497]*work.v[598];
work.v[600] = target[733]-work.L[498]*work.v[213];
work.v[601] = target[71]-work.L[499]*work.v[600];
work.v[602] = target[734]-work.L[500]*work.v[214]-work.L[501]*work.v[601];
work.v[603] = target[735]-work.L[502]*work.v[215]-work.L[503]*work.v[601]-work.L[504]*work.v[602];
work.v[604] = target[736]-work.L[505]*work.v[216];
work.v[605] = target[72]-work.L[506]*work.v[604];
work.v[606] = target[737]-work.L[507]*work.v[217]-work.L[508]*work.v[605];
work.v[607] = target[738]-work.L[509]*work.v[218]-work.L[510]*work.v[605]-work.L[511]*work.v[606];
work.v[608] = target[739]-work.L[512]*work.v[219];
work.v[609] = target[73]-work.L[513]*work.v[608];
work.v[610] = target[740]-work.L[514]*work.v[220]-work.L[515]*work.v[609];
work.v[611] = target[741]-work.L[516]*work.v[221]-work.L[517]*work.v[609]-work.L[518]*work.v[610];
work.v[612] = target[742]-work.L[519]*work.v[222];
work.v[613] = target[74]-work.L[520]*work.v[612];
work.v[614] = target[743]-work.L[521]*work.v[223]-work.L[522]*work.v[613];
work.v[615] = target[744]-work.L[523]*work.v[224]-work.L[524]*work.v[613]-work.L[525]*work.v[614];
work.v[616] = target[745]-work.L[526]*work.v[225];
work.v[617] = target[75]-work.L[527]*work.v[616];
work.v[618] = target[746]-work.L[528]*work.v[226]-work.L[529]*work.v[617];
work.v[619] = target[747]-work.L[530]*work.v[227]-work.L[531]*work.v[617]-work.L[532]*work.v[618];
work.v[620] = target[748]-work.L[533]*work.v[228];
work.v[621] = target[76]-work.L[534]*work.v[620];
work.v[622] = target[749]-work.L[535]*work.v[229]-work.L[536]*work.v[621];
work.v[623] = target[750]-work.L[537]*work.v[230]-work.L[538]*work.v[621]-work.L[539]*work.v[622];
work.v[624] = target[751]-work.L[540]*work.v[231];
work.v[625] = target[77]-work.L[541]*work.v[624];
work.v[626] = target[752]-work.L[542]*work.v[232]-work.L[543]*work.v[625];
work.v[627] = target[753]-work.L[544]*work.v[233]-work.L[545]*work.v[625]-work.L[546]*work.v[626];
work.v[628] = target[206]-work.L[547]*work.v[626]-work.L[548]*work.v[627];
work.v[629] = target[754]-work.L[549]*work.v[234];
work.v[630] = target[78]-work.L[550]*work.v[629];
work.v[631] = target[755]-work.L[551]*work.v[235]-work.L[552]*work.v[630];
work.v[632] = target[756]-work.L[553]*work.v[236]-work.L[554]*work.v[630]-work.L[555]*work.v[631];
work.v[633] = target[757]-work.L[556]*work.v[237];
work.v[634] = target[79]-work.L[557]*work.v[633];
work.v[635] = target[758]-work.L[558]*work.v[238]-work.L[559]*work.v[634];
work.v[636] = target[759]-work.L[560]*work.v[239]-work.L[561]*work.v[634]-work.L[562]*work.v[635];
work.v[637] = target[760]-work.L[563]*work.v[240];
work.v[638] = target[80]-work.L[564]*work.v[637];
work.v[639] = target[761]-work.L[565]*work.v[241]-work.L[566]*work.v[638];
work.v[640] = target[762]-work.L[567]*work.v[242]-work.L[568]*work.v[638]-work.L[569]*work.v[639];
work.v[641] = target[763]-work.L[570]*work.v[243];
work.v[642] = target[81]-work.L[571]*work.v[641];
work.v[643] = target[764]-work.L[572]*work.v[244]-work.L[573]*work.v[642];
work.v[644] = target[765]-work.L[574]*work.v[245]-work.L[575]*work.v[642]-work.L[576]*work.v[643];
work.v[645] = target[766]-work.L[577]*work.v[246];
work.v[646] = target[82]-work.L[578]*work.v[645];
work.v[647] = target[767]-work.L[579]*work.v[247]-work.L[580]*work.v[646];
work.v[648] = target[768]-work.L[581]*work.v[248]-work.L[582]*work.v[646]-work.L[583]*work.v[647];
work.v[649] = target[769]-work.L[584]*work.v[249];
work.v[650] = target[83]-work.L[585]*work.v[649];
work.v[651] = target[770]-work.L[586]*work.v[250]-work.L[587]*work.v[650];
work.v[652] = target[771]-work.L[588]*work.v[251]-work.L[589]*work.v[650]-work.L[590]*work.v[651];
work.v[653] = target[772]-work.L[591]*work.v[252];
work.v[654] = target[84]-work.L[592]*work.v[653];
work.v[655] = target[773]-work.L[593]*work.v[253]-work.L[594]*work.v[654];
work.v[656] = target[774]-work.L[595]*work.v[254]-work.L[596]*work.v[654]-work.L[597]*work.v[655];
work.v[657] = target[775]-work.L[598]*work.v[255];
work.v[658] = target[85]-work.L[599]*work.v[657];
work.v[659] = target[776]-work.L[600]*work.v[256]-work.L[601]*work.v[658];
work.v[660] = target[777]-work.L[602]*work.v[257]-work.L[603]*work.v[658]-work.L[604]*work.v[659];
work.v[661] = target[778]-work.L[605]*work.v[258];
work.v[662] = target[86]-work.L[606]*work.v[661];
work.v[663] = target[779]-work.L[607]*work.v[259]-work.L[608]*work.v[662];
work.v[664] = target[780]-work.L[609]*work.v[260]-work.L[610]*work.v[662]-work.L[611]*work.v[663];
work.v[665] = target[781]-work.L[612]*work.v[261];
work.v[666] = target[87]-work.L[613]*work.v[665];
work.v[667] = target[782]-work.L[614]*work.v[262]-work.L[615]*work.v[666];
work.v[668] = target[783]-work.L[616]*work.v[263]-work.L[617]*work.v[666]-work.L[618]*work.v[667];
work.v[669] = target[784]-work.L[619]*work.v[264];
work.v[670] = target[88]-work.L[620]*work.v[669];
work.v[671] = target[785]-work.L[621]*work.v[265]-work.L[622]*work.v[670];
work.v[672] = target[786]-work.L[623]*work.v[266]-work.L[624]*work.v[670]-work.L[625]*work.v[671];
work.v[673] = target[787]-work.L[626]*work.v[267];
work.v[674] = target[89]-work.L[627]*work.v[673];
work.v[675] = target[788]-work.L[628]*work.v[268]-work.L[629]*work.v[674];
work.v[676] = target[789]-work.L[630]*work.v[269]-work.L[631]*work.v[674]-work.L[632]*work.v[675];
work.v[677] = target[790]-work.L[633]*work.v[270];
work.v[678] = target[90]-work.L[634]*work.v[677];
work.v[679] = target[791]-work.L[635]*work.v[271]-work.L[636]*work.v[678];
work.v[680] = target[792]-work.L[637]*work.v[272]-work.L[638]*work.v[678]-work.L[639]*work.v[679];
work.v[681] = target[793]-work.L[640]*work.v[273];
work.v[682] = target[91]-work.L[641]*work.v[681];
work.v[683] = target[794]-work.L[642]*work.v[274]-work.L[643]*work.v[682];
work.v[684] = target[795]-work.L[644]*work.v[275]-work.L[645]*work.v[682]-work.L[646]*work.v[683];
work.v[685] = target[796]-work.L[647]*work.v[276];
work.v[686] = target[92]-work.L[648]*work.v[685];
work.v[687] = target[797]-work.L[649]*work.v[277]-work.L[650]*work.v[686];
work.v[688] = target[798]-work.L[651]*work.v[278]-work.L[652]*work.v[686]-work.L[653]*work.v[687];
work.v[689] = target[799]-work.L[654]*work.v[279];
work.v[690] = target[93]-work.L[655]*work.v[689];
work.v[691] = target[800]-work.L[656]*work.v[280]-work.L[657]*work.v[690];
work.v[692] = target[801]-work.L[658]*work.v[281]-work.L[659]*work.v[690]-work.L[660]*work.v[691];
work.v[693] = target[802]-work.L[661]*work.v[282];
work.v[694] = target[94]-work.L[662]*work.v[693];
work.v[695] = target[803]-work.L[663]*work.v[283]-work.L[664]*work.v[694];
work.v[696] = target[804]-work.L[665]*work.v[284]-work.L[666]*work.v[694]-work.L[667]*work.v[695];
work.v[697] = target[805]-work.L[668]*work.v[285];
work.v[698] = target[95]-work.L[669]*work.v[697];
work.v[699] = target[806]-work.L[670]*work.v[286]-work.L[671]*work.v[698];
work.v[700] = target[807]-work.L[672]*work.v[287]-work.L[673]*work.v[698]-work.L[674]*work.v[699];
work.v[701] = target[808]-work.L[675]*work.v[288];
work.v[702] = target[96]-work.L[676]*work.v[701];
work.v[703] = target[809]-work.L[677]*work.v[289]-work.L[678]*work.v[702];
work.v[704] = target[810]-work.L[679]*work.v[290]-work.L[680]*work.v[702]-work.L[681]*work.v[703];
work.v[705] = target[811]-work.L[682]*work.v[291];
work.v[706] = target[97]-work.L[683]*work.v[705];
work.v[707] = target[812]-work.L[684]*work.v[292]-work.L[685]*work.v[706];
work.v[708] = target[813]-work.L[686]*work.v[293]-work.L[687]*work.v[706]-work.L[688]*work.v[707];
work.v[709] = target[814]-work.L[689]*work.v[294];
work.v[710] = target[98]-work.L[690]*work.v[709];
work.v[711] = target[815]-work.L[691]*work.v[295]-work.L[692]*work.v[710];
work.v[712] = target[816]-work.L[693]*work.v[296]-work.L[694]*work.v[710]-work.L[695]*work.v[711];
work.v[713] = target[817]-work.L[696]*work.v[297];
work.v[714] = target[99]-work.L[697]*work.v[713];
work.v[715] = target[818]-work.L[698]*work.v[298]-work.L[699]*work.v[714];
work.v[716] = target[819]-work.L[700]*work.v[299]-work.L[701]*work.v[714]-work.L[702]*work.v[715];
work.v[717] = target[820]-work.L[703]*work.v[300];
work.v[718] = target[100]-work.L[704]*work.v[717];
work.v[719] = target[821]-work.L[705]*work.v[301]-work.L[706]*work.v[718];
work.v[720] = target[822]-work.L[707]*work.v[302]-work.L[708]*work.v[718]-work.L[709]*work.v[719];
work.v[721] = target[823]-work.L[710]*work.v[303];
work.v[722] = target[101]-work.L[711]*work.v[721];
work.v[723] = target[824]-work.L[712]*work.v[304]-work.L[713]*work.v[722];
work.v[724] = target[825]-work.L[714]*work.v[305]-work.L[715]*work.v[722]-work.L[716]*work.v[723];
work.v[725] = target[826]-work.L[717]*work.v[306];
work.v[726] = target[102]-work.L[718]*work.v[725];
work.v[727] = target[827]-work.L[719]*work.v[307]-work.L[720]*work.v[726];
work.v[728] = target[828]-work.L[721]*work.v[308]-work.L[722]*work.v[726]-work.L[723]*work.v[727];
work.v[729] = target[829]-work.L[724]*work.v[309];
work.v[730] = target[103]-work.L[725]*work.v[729];
work.v[731] = target[830]-work.L[726]*work.v[310]-work.L[727]*work.v[730];
work.v[732] = target[831]-work.L[728]*work.v[311]-work.L[729]*work.v[730]-work.L[730]*work.v[731];
work.v[733] = target[207]-work.L[731]*work.v[731]-work.L[732]*work.v[732];
work.v[734] = target[129]-work.L[733]*work.v[418]-work.L[734]*work.v[419]-work.L[735]*work.v[522]-work.L[736]*work.v[523];
work.v[735] = target[834];
work.v[736] = target[104]-work.L[737]*work.v[318]-work.L[738]*work.v[319]-work.L[739]*work.v[422]-work.L[740]*work.v[423]-work.L[741]*work.v[426]-work.L[742]*work.v[427]-work.L[743]*work.v[735];
work.v[737] = target[835]-work.L[744]*work.v[314];
work.v[738] = target[907]-work.L[745]*work.v[315];
work.v[739] = target[908]-work.L[746]*work.v[628];
work.v[740] = target[909]-work.L[747]*work.v[733]-work.L[748]*work.v[734];
work.v[741] = target[131]-work.L[749]*work.v[313]-work.L[750]*work.v[526]-work.L[751]*work.v[527]-work.L[752]*work.v[737];
work.v[742] = target[133]-work.L[753]*work.v[737]-work.L[754]*work.v[741];
work.v[743] = target[136];
work.v[744] = target[139];
work.v[745] = target[142];
work.v[746] = target[145];
work.v[747] = target[148];
work.v[748] = target[151];
work.v[749] = target[154];
work.v[750] = target[157];
work.v[751] = target[160];
work.v[752] = target[163];
work.v[753] = target[166];
work.v[754] = target[169];
work.v[755] = target[172];
work.v[756] = target[175];
work.v[757] = target[178];
work.v[758] = target[181];
work.v[759] = target[184];
work.v[760] = target[187];
work.v[761] = target[190];
work.v[762] = target[193];
work.v[763] = target[196];
work.v[764] = target[199];
work.v[765] = target[202]-work.L[755]*work.v[738];
work.v[766] = target[836]-work.L[756]*work.v[741]-work.L[757]*work.v[742];
work.v[767] = target[837];
work.v[768] = target[105]-work.L[758]*work.v[322]-work.L[759]*work.v[323]-work.L[760]*work.v[426]-work.L[761]*work.v[427]-work.L[762]*work.v[430]-work.L[763]*work.v[431]-work.L[764]*work.v[736]-work.L[765]*work.v[767];
work.v[769] = target[838]-work.L[766]*work.v[742]-work.L[767]*work.v[743]-work.L[768]*work.v[766];
work.v[770] = target[840];
work.v[771] = target[906];
work.v[772] = target[128]-work.L[769]*work.v[414]-work.L[770]*work.v[415]-work.L[771]*work.v[518]-work.L[772]*work.v[519]-work.L[773]*work.v[522]-work.L[774]*work.v[523]-work.L[775]*work.v[734]-work.L[776]*work.v[740]-work.L[777]*work.v[771];
work.v[773] = target[204]-work.L[778]*work.v[727]-work.L[779]*work.v[728]-work.L[780]*work.v[739]-work.L[781]*work.v[740]-work.L[782]*work.v[771]-work.L[783]*work.v[772];
work.v[774] = target[903];
work.v[775] = target[905];
work.v[776] = target[904]-work.L[784]*work.v[764]-work.L[785]*work.v[765];
work.v[777] = target[134]-work.L[786]*work.v[530]-work.L[787]*work.v[531]-work.L[788]*work.v[766]-work.L[789]*work.v[769];
work.v[778] = target[132]-work.L[790]*work.v[631]-work.L[791]*work.v[632]-work.L[792]*work.v[735]-work.L[793]*work.v[736]-work.L[794]*work.v[766]-work.L[795]*work.v[767]-work.L[796]*work.v[768]-work.L[797]*work.v[769]-work.L[798]*work.v[777];
work.v[779] = target[135]-work.L[799]*work.v[635]-work.L[800]*work.v[636]-work.L[801]*work.v[767]-work.L[802]*work.v[768]-work.L[803]*work.v[770]-work.L[804]*work.v[778];
work.v[780] = target[839]-work.L[805]*work.v[777]-work.L[806]*work.v[778]-work.L[807]*work.v[779];
work.v[781] = target[842];
work.v[782] = target[137]-work.L[808]*work.v[534]-work.L[809]*work.v[535]-work.L[810]*work.v[780]-work.L[811]*work.v[781];
work.v[783] = target[841]-work.L[812]*work.v[743]-work.L[813]*work.v[744]-work.L[814]*work.v[769]-work.L[815]*work.v[777]-work.L[816]*work.v[778]-work.L[817]*work.v[779]-work.L[818]*work.v[780]-work.L[819]*work.v[782];
work.v[784] = target[106]-work.L[820]*work.v[326]-work.L[821]*work.v[327]-work.L[822]*work.v[430]-work.L[823]*work.v[431]-work.L[824]*work.v[434]-work.L[825]*work.v[435]-work.L[826]*work.v[768]-work.L[827]*work.v[770]-work.L[828]*work.v[778]-work.L[829]*work.v[779]-work.L[830]*work.v[780]-work.L[831]*work.v[782]-work.L[832]*work.v[783];
work.v[785] = target[843];
work.v[786] = target[138]-work.L[833]*work.v[639]-work.L[834]*work.v[640]-work.L[835]*work.v[770]-work.L[836]*work.v[779]-work.L[837]*work.v[780]-work.L[838]*work.v[781]-work.L[839]*work.v[782]-work.L[840]*work.v[783]-work.L[841]*work.v[784]-work.L[842]*work.v[785];
work.v[787] = target[845];
work.v[788] = target[140]-work.L[843]*work.v[538]-work.L[844]*work.v[539]-work.L[845]*work.v[781]-work.L[846]*work.v[782]-work.L[847]*work.v[783]-work.L[848]*work.v[784]-work.L[849]*work.v[786]-work.L[850]*work.v[787];
work.v[789] = target[844]-work.L[851]*work.v[744]-work.L[852]*work.v[745]-work.L[853]*work.v[783]-work.L[854]*work.v[784]-work.L[855]*work.v[786]-work.L[856]*work.v[788];
work.v[790] = target[107]-work.L[857]*work.v[330]-work.L[858]*work.v[331]-work.L[859]*work.v[434]-work.L[860]*work.v[435]-work.L[861]*work.v[438]-work.L[862]*work.v[439]-work.L[863]*work.v[784]-work.L[864]*work.v[785]-work.L[865]*work.v[786]-work.L[866]*work.v[788]-work.L[867]*work.v[789];
work.v[791] = target[846];
work.v[792] = target[141]-work.L[868]*work.v[643]-work.L[869]*work.v[644]-work.L[870]*work.v[785]-work.L[871]*work.v[786]-work.L[872]*work.v[787]-work.L[873]*work.v[788]-work.L[874]*work.v[789]-work.L[875]*work.v[790]-work.L[876]*work.v[791];
work.v[793] = target[848];
work.v[794] = target[143]-work.L[877]*work.v[542]-work.L[878]*work.v[543]-work.L[879]*work.v[787]-work.L[880]*work.v[788]-work.L[881]*work.v[789]-work.L[882]*work.v[790]-work.L[883]*work.v[792]-work.L[884]*work.v[793];
work.v[795] = target[847]-work.L[885]*work.v[745]-work.L[886]*work.v[746]-work.L[887]*work.v[789]-work.L[888]*work.v[790]-work.L[889]*work.v[792]-work.L[890]*work.v[794];
work.v[796] = target[108]-work.L[891]*work.v[334]-work.L[892]*work.v[335]-work.L[893]*work.v[438]-work.L[894]*work.v[439]-work.L[895]*work.v[442]-work.L[896]*work.v[443]-work.L[897]*work.v[790]-work.L[898]*work.v[791]-work.L[899]*work.v[792]-work.L[900]*work.v[794]-work.L[901]*work.v[795];
work.v[797] = target[849];
work.v[798] = target[144]-work.L[902]*work.v[647]-work.L[903]*work.v[648]-work.L[904]*work.v[791]-work.L[905]*work.v[792]-work.L[906]*work.v[793]-work.L[907]*work.v[794]-work.L[908]*work.v[795]-work.L[909]*work.v[796]-work.L[910]*work.v[797];
work.v[799] = target[851];
work.v[800] = target[146]-work.L[911]*work.v[546]-work.L[912]*work.v[547]-work.L[913]*work.v[793]-work.L[914]*work.v[794]-work.L[915]*work.v[795]-work.L[916]*work.v[796]-work.L[917]*work.v[798]-work.L[918]*work.v[799];
work.v[801] = target[850]-work.L[919]*work.v[746]-work.L[920]*work.v[747]-work.L[921]*work.v[795]-work.L[922]*work.v[796]-work.L[923]*work.v[798]-work.L[924]*work.v[800];
work.v[802] = target[109]-work.L[925]*work.v[338]-work.L[926]*work.v[339]-work.L[927]*work.v[442]-work.L[928]*work.v[443]-work.L[929]*work.v[446]-work.L[930]*work.v[447]-work.L[931]*work.v[796]-work.L[932]*work.v[797]-work.L[933]*work.v[798]-work.L[934]*work.v[800]-work.L[935]*work.v[801];
work.v[803] = target[852];
work.v[804] = target[147]-work.L[936]*work.v[651]-work.L[937]*work.v[652]-work.L[938]*work.v[797]-work.L[939]*work.v[798]-work.L[940]*work.v[799]-work.L[941]*work.v[800]-work.L[942]*work.v[801]-work.L[943]*work.v[802]-work.L[944]*work.v[803];
work.v[805] = target[854];
work.v[806] = target[149]-work.L[945]*work.v[550]-work.L[946]*work.v[551]-work.L[947]*work.v[799]-work.L[948]*work.v[800]-work.L[949]*work.v[801]-work.L[950]*work.v[802]-work.L[951]*work.v[804]-work.L[952]*work.v[805];
work.v[807] = target[853]-work.L[953]*work.v[747]-work.L[954]*work.v[748]-work.L[955]*work.v[801]-work.L[956]*work.v[802]-work.L[957]*work.v[804]-work.L[958]*work.v[806];
work.v[808] = target[110]-work.L[959]*work.v[342]-work.L[960]*work.v[343]-work.L[961]*work.v[446]-work.L[962]*work.v[447]-work.L[963]*work.v[450]-work.L[964]*work.v[451]-work.L[965]*work.v[802]-work.L[966]*work.v[803]-work.L[967]*work.v[804]-work.L[968]*work.v[806]-work.L[969]*work.v[807];
work.v[809] = target[855];
work.v[810] = target[150]-work.L[970]*work.v[655]-work.L[971]*work.v[656]-work.L[972]*work.v[803]-work.L[973]*work.v[804]-work.L[974]*work.v[805]-work.L[975]*work.v[806]-work.L[976]*work.v[807]-work.L[977]*work.v[808]-work.L[978]*work.v[809];
work.v[811] = target[857];
work.v[812] = target[152]-work.L[979]*work.v[554]-work.L[980]*work.v[555]-work.L[981]*work.v[805]-work.L[982]*work.v[806]-work.L[983]*work.v[807]-work.L[984]*work.v[808]-work.L[985]*work.v[810]-work.L[986]*work.v[811];
work.v[813] = target[856]-work.L[987]*work.v[748]-work.L[988]*work.v[749]-work.L[989]*work.v[807]-work.L[990]*work.v[808]-work.L[991]*work.v[810]-work.L[992]*work.v[812];
work.v[814] = target[111]-work.L[993]*work.v[346]-work.L[994]*work.v[347]-work.L[995]*work.v[450]-work.L[996]*work.v[451]-work.L[997]*work.v[454]-work.L[998]*work.v[455]-work.L[999]*work.v[808]-work.L[1000]*work.v[809]-work.L[1001]*work.v[810]-work.L[1002]*work.v[812]-work.L[1003]*work.v[813];
work.v[815] = target[858];
work.v[816] = target[153]-work.L[1004]*work.v[659]-work.L[1005]*work.v[660]-work.L[1006]*work.v[809]-work.L[1007]*work.v[810]-work.L[1008]*work.v[811]-work.L[1009]*work.v[812]-work.L[1010]*work.v[813]-work.L[1011]*work.v[814]-work.L[1012]*work.v[815];
work.v[817] = target[860];
work.v[818] = target[155]-work.L[1013]*work.v[558]-work.L[1014]*work.v[559]-work.L[1015]*work.v[811]-work.L[1016]*work.v[812]-work.L[1017]*work.v[813]-work.L[1018]*work.v[814]-work.L[1019]*work.v[816]-work.L[1020]*work.v[817];
work.v[819] = target[859]-work.L[1021]*work.v[749]-work.L[1022]*work.v[750]-work.L[1023]*work.v[813]-work.L[1024]*work.v[814]-work.L[1025]*work.v[816]-work.L[1026]*work.v[818];
work.v[820] = target[112]-work.L[1027]*work.v[350]-work.L[1028]*work.v[351]-work.L[1029]*work.v[454]-work.L[1030]*work.v[455]-work.L[1031]*work.v[458]-work.L[1032]*work.v[459]-work.L[1033]*work.v[814]-work.L[1034]*work.v[815]-work.L[1035]*work.v[816]-work.L[1036]*work.v[818]-work.L[1037]*work.v[819];
work.v[821] = target[861];
work.v[822] = target[156]-work.L[1038]*work.v[663]-work.L[1039]*work.v[664]-work.L[1040]*work.v[815]-work.L[1041]*work.v[816]-work.L[1042]*work.v[817]-work.L[1043]*work.v[818]-work.L[1044]*work.v[819]-work.L[1045]*work.v[820]-work.L[1046]*work.v[821];
work.v[823] = target[863];
work.v[824] = target[158]-work.L[1047]*work.v[562]-work.L[1048]*work.v[563]-work.L[1049]*work.v[817]-work.L[1050]*work.v[818]-work.L[1051]*work.v[819]-work.L[1052]*work.v[820]-work.L[1053]*work.v[822]-work.L[1054]*work.v[823];
work.v[825] = target[862]-work.L[1055]*work.v[750]-work.L[1056]*work.v[751]-work.L[1057]*work.v[819]-work.L[1058]*work.v[820]-work.L[1059]*work.v[822]-work.L[1060]*work.v[824];
work.v[826] = target[113]-work.L[1061]*work.v[354]-work.L[1062]*work.v[355]-work.L[1063]*work.v[458]-work.L[1064]*work.v[459]-work.L[1065]*work.v[462]-work.L[1066]*work.v[463]-work.L[1067]*work.v[820]-work.L[1068]*work.v[821]-work.L[1069]*work.v[822]-work.L[1070]*work.v[824]-work.L[1071]*work.v[825];
work.v[827] = target[864];
work.v[828] = target[159]-work.L[1072]*work.v[667]-work.L[1073]*work.v[668]-work.L[1074]*work.v[821]-work.L[1075]*work.v[822]-work.L[1076]*work.v[823]-work.L[1077]*work.v[824]-work.L[1078]*work.v[825]-work.L[1079]*work.v[826]-work.L[1080]*work.v[827];
work.v[829] = target[866];
work.v[830] = target[161]-work.L[1081]*work.v[566]-work.L[1082]*work.v[567]-work.L[1083]*work.v[823]-work.L[1084]*work.v[824]-work.L[1085]*work.v[825]-work.L[1086]*work.v[826]-work.L[1087]*work.v[828]-work.L[1088]*work.v[829];
work.v[831] = target[865]-work.L[1089]*work.v[751]-work.L[1090]*work.v[752]-work.L[1091]*work.v[825]-work.L[1092]*work.v[826]-work.L[1093]*work.v[828]-work.L[1094]*work.v[830];
work.v[832] = target[114]-work.L[1095]*work.v[358]-work.L[1096]*work.v[359]-work.L[1097]*work.v[462]-work.L[1098]*work.v[463]-work.L[1099]*work.v[466]-work.L[1100]*work.v[467]-work.L[1101]*work.v[826]-work.L[1102]*work.v[827]-work.L[1103]*work.v[828]-work.L[1104]*work.v[830]-work.L[1105]*work.v[831];
work.v[833] = target[867];
work.v[834] = target[162]-work.L[1106]*work.v[671]-work.L[1107]*work.v[672]-work.L[1108]*work.v[827]-work.L[1109]*work.v[828]-work.L[1110]*work.v[829]-work.L[1111]*work.v[830]-work.L[1112]*work.v[831]-work.L[1113]*work.v[832]-work.L[1114]*work.v[833];
work.v[835] = target[869];
work.v[836] = target[164]-work.L[1115]*work.v[570]-work.L[1116]*work.v[571]-work.L[1117]*work.v[829]-work.L[1118]*work.v[830]-work.L[1119]*work.v[831]-work.L[1120]*work.v[832]-work.L[1121]*work.v[834]-work.L[1122]*work.v[835];
work.v[837] = target[868]-work.L[1123]*work.v[752]-work.L[1124]*work.v[753]-work.L[1125]*work.v[831]-work.L[1126]*work.v[832]-work.L[1127]*work.v[834]-work.L[1128]*work.v[836];
work.v[838] = target[115]-work.L[1129]*work.v[362]-work.L[1130]*work.v[363]-work.L[1131]*work.v[466]-work.L[1132]*work.v[467]-work.L[1133]*work.v[470]-work.L[1134]*work.v[471]-work.L[1135]*work.v[832]-work.L[1136]*work.v[833]-work.L[1137]*work.v[834]-work.L[1138]*work.v[836]-work.L[1139]*work.v[837];
work.v[839] = target[870];
work.v[840] = target[165]-work.L[1140]*work.v[675]-work.L[1141]*work.v[676]-work.L[1142]*work.v[833]-work.L[1143]*work.v[834]-work.L[1144]*work.v[835]-work.L[1145]*work.v[836]-work.L[1146]*work.v[837]-work.L[1147]*work.v[838]-work.L[1148]*work.v[839];
work.v[841] = target[872];
work.v[842] = target[167]-work.L[1149]*work.v[574]-work.L[1150]*work.v[575]-work.L[1151]*work.v[835]-work.L[1152]*work.v[836]-work.L[1153]*work.v[837]-work.L[1154]*work.v[838]-work.L[1155]*work.v[840]-work.L[1156]*work.v[841];
work.v[843] = target[871]-work.L[1157]*work.v[753]-work.L[1158]*work.v[754]-work.L[1159]*work.v[837]-work.L[1160]*work.v[838]-work.L[1161]*work.v[840]-work.L[1162]*work.v[842];
work.v[844] = target[116]-work.L[1163]*work.v[366]-work.L[1164]*work.v[367]-work.L[1165]*work.v[470]-work.L[1166]*work.v[471]-work.L[1167]*work.v[474]-work.L[1168]*work.v[475]-work.L[1169]*work.v[838]-work.L[1170]*work.v[839]-work.L[1171]*work.v[840]-work.L[1172]*work.v[842]-work.L[1173]*work.v[843];
work.v[845] = target[873];
work.v[846] = target[168]-work.L[1174]*work.v[679]-work.L[1175]*work.v[680]-work.L[1176]*work.v[839]-work.L[1177]*work.v[840]-work.L[1178]*work.v[841]-work.L[1179]*work.v[842]-work.L[1180]*work.v[843]-work.L[1181]*work.v[844]-work.L[1182]*work.v[845];
work.v[847] = target[875];
work.v[848] = target[170]-work.L[1183]*work.v[578]-work.L[1184]*work.v[579]-work.L[1185]*work.v[841]-work.L[1186]*work.v[842]-work.L[1187]*work.v[843]-work.L[1188]*work.v[844]-work.L[1189]*work.v[846]-work.L[1190]*work.v[847];
work.v[849] = target[874]-work.L[1191]*work.v[754]-work.L[1192]*work.v[755]-work.L[1193]*work.v[843]-work.L[1194]*work.v[844]-work.L[1195]*work.v[846]-work.L[1196]*work.v[848];
work.v[850] = target[117]-work.L[1197]*work.v[370]-work.L[1198]*work.v[371]-work.L[1199]*work.v[474]-work.L[1200]*work.v[475]-work.L[1201]*work.v[478]-work.L[1202]*work.v[479]-work.L[1203]*work.v[844]-work.L[1204]*work.v[845]-work.L[1205]*work.v[846]-work.L[1206]*work.v[848]-work.L[1207]*work.v[849];
work.v[851] = target[876];
work.v[852] = target[171]-work.L[1208]*work.v[683]-work.L[1209]*work.v[684]-work.L[1210]*work.v[845]-work.L[1211]*work.v[846]-work.L[1212]*work.v[847]-work.L[1213]*work.v[848]-work.L[1214]*work.v[849]-work.L[1215]*work.v[850]-work.L[1216]*work.v[851];
work.v[853] = target[878];
work.v[854] = target[173]-work.L[1217]*work.v[582]-work.L[1218]*work.v[583]-work.L[1219]*work.v[847]-work.L[1220]*work.v[848]-work.L[1221]*work.v[849]-work.L[1222]*work.v[850]-work.L[1223]*work.v[852]-work.L[1224]*work.v[853];
work.v[855] = target[877]-work.L[1225]*work.v[755]-work.L[1226]*work.v[756]-work.L[1227]*work.v[849]-work.L[1228]*work.v[850]-work.L[1229]*work.v[852]-work.L[1230]*work.v[854];
work.v[856] = target[118]-work.L[1231]*work.v[374]-work.L[1232]*work.v[375]-work.L[1233]*work.v[478]-work.L[1234]*work.v[479]-work.L[1235]*work.v[482]-work.L[1236]*work.v[483]-work.L[1237]*work.v[850]-work.L[1238]*work.v[851]-work.L[1239]*work.v[852]-work.L[1240]*work.v[854]-work.L[1241]*work.v[855];
work.v[857] = target[879];
work.v[858] = target[174]-work.L[1242]*work.v[687]-work.L[1243]*work.v[688]-work.L[1244]*work.v[851]-work.L[1245]*work.v[852]-work.L[1246]*work.v[853]-work.L[1247]*work.v[854]-work.L[1248]*work.v[855]-work.L[1249]*work.v[856]-work.L[1250]*work.v[857];
work.v[859] = target[881];
work.v[860] = target[176]-work.L[1251]*work.v[586]-work.L[1252]*work.v[587]-work.L[1253]*work.v[853]-work.L[1254]*work.v[854]-work.L[1255]*work.v[855]-work.L[1256]*work.v[856]-work.L[1257]*work.v[858]-work.L[1258]*work.v[859];
work.v[861] = target[880]-work.L[1259]*work.v[756]-work.L[1260]*work.v[757]-work.L[1261]*work.v[855]-work.L[1262]*work.v[856]-work.L[1263]*work.v[858]-work.L[1264]*work.v[860];
work.v[862] = target[119]-work.L[1265]*work.v[378]-work.L[1266]*work.v[379]-work.L[1267]*work.v[482]-work.L[1268]*work.v[483]-work.L[1269]*work.v[486]-work.L[1270]*work.v[487]-work.L[1271]*work.v[856]-work.L[1272]*work.v[857]-work.L[1273]*work.v[858]-work.L[1274]*work.v[860]-work.L[1275]*work.v[861];
work.v[863] = target[882];
work.v[864] = target[177]-work.L[1276]*work.v[691]-work.L[1277]*work.v[692]-work.L[1278]*work.v[857]-work.L[1279]*work.v[858]-work.L[1280]*work.v[859]-work.L[1281]*work.v[860]-work.L[1282]*work.v[861]-work.L[1283]*work.v[862]-work.L[1284]*work.v[863];
work.v[865] = target[884];
work.v[866] = target[179]-work.L[1285]*work.v[590]-work.L[1286]*work.v[591]-work.L[1287]*work.v[859]-work.L[1288]*work.v[860]-work.L[1289]*work.v[861]-work.L[1290]*work.v[862]-work.L[1291]*work.v[864]-work.L[1292]*work.v[865];
work.v[867] = target[883]-work.L[1293]*work.v[757]-work.L[1294]*work.v[758]-work.L[1295]*work.v[861]-work.L[1296]*work.v[862]-work.L[1297]*work.v[864]-work.L[1298]*work.v[866];
work.v[868] = target[120]-work.L[1299]*work.v[382]-work.L[1300]*work.v[383]-work.L[1301]*work.v[486]-work.L[1302]*work.v[487]-work.L[1303]*work.v[490]-work.L[1304]*work.v[491]-work.L[1305]*work.v[862]-work.L[1306]*work.v[863]-work.L[1307]*work.v[864]-work.L[1308]*work.v[866]-work.L[1309]*work.v[867];
work.v[869] = target[885];
work.v[870] = target[180]-work.L[1310]*work.v[695]-work.L[1311]*work.v[696]-work.L[1312]*work.v[863]-work.L[1313]*work.v[864]-work.L[1314]*work.v[865]-work.L[1315]*work.v[866]-work.L[1316]*work.v[867]-work.L[1317]*work.v[868]-work.L[1318]*work.v[869];
work.v[871] = target[887];
work.v[872] = target[182]-work.L[1319]*work.v[594]-work.L[1320]*work.v[595]-work.L[1321]*work.v[865]-work.L[1322]*work.v[866]-work.L[1323]*work.v[867]-work.L[1324]*work.v[868]-work.L[1325]*work.v[870]-work.L[1326]*work.v[871];
work.v[873] = target[886]-work.L[1327]*work.v[758]-work.L[1328]*work.v[759]-work.L[1329]*work.v[867]-work.L[1330]*work.v[868]-work.L[1331]*work.v[870]-work.L[1332]*work.v[872];
work.v[874] = target[121]-work.L[1333]*work.v[386]-work.L[1334]*work.v[387]-work.L[1335]*work.v[490]-work.L[1336]*work.v[491]-work.L[1337]*work.v[494]-work.L[1338]*work.v[495]-work.L[1339]*work.v[868]-work.L[1340]*work.v[869]-work.L[1341]*work.v[870]-work.L[1342]*work.v[872]-work.L[1343]*work.v[873];
work.v[875] = target[888];
work.v[876] = target[183]-work.L[1344]*work.v[699]-work.L[1345]*work.v[700]-work.L[1346]*work.v[869]-work.L[1347]*work.v[870]-work.L[1348]*work.v[871]-work.L[1349]*work.v[872]-work.L[1350]*work.v[873]-work.L[1351]*work.v[874]-work.L[1352]*work.v[875];
work.v[877] = target[890];
work.v[878] = target[185]-work.L[1353]*work.v[598]-work.L[1354]*work.v[599]-work.L[1355]*work.v[871]-work.L[1356]*work.v[872]-work.L[1357]*work.v[873]-work.L[1358]*work.v[874]-work.L[1359]*work.v[876]-work.L[1360]*work.v[877];
work.v[879] = target[889]-work.L[1361]*work.v[759]-work.L[1362]*work.v[760]-work.L[1363]*work.v[873]-work.L[1364]*work.v[874]-work.L[1365]*work.v[876]-work.L[1366]*work.v[878];
work.v[880] = target[122]-work.L[1367]*work.v[390]-work.L[1368]*work.v[391]-work.L[1369]*work.v[494]-work.L[1370]*work.v[495]-work.L[1371]*work.v[498]-work.L[1372]*work.v[499]-work.L[1373]*work.v[874]-work.L[1374]*work.v[875]-work.L[1375]*work.v[876]-work.L[1376]*work.v[878]-work.L[1377]*work.v[879];
work.v[881] = target[891];
work.v[882] = target[186]-work.L[1378]*work.v[703]-work.L[1379]*work.v[704]-work.L[1380]*work.v[875]-work.L[1381]*work.v[876]-work.L[1382]*work.v[877]-work.L[1383]*work.v[878]-work.L[1384]*work.v[879]-work.L[1385]*work.v[880]-work.L[1386]*work.v[881];
work.v[883] = target[893];
work.v[884] = target[188]-work.L[1387]*work.v[602]-work.L[1388]*work.v[603]-work.L[1389]*work.v[877]-work.L[1390]*work.v[878]-work.L[1391]*work.v[879]-work.L[1392]*work.v[880]-work.L[1393]*work.v[882]-work.L[1394]*work.v[883];
work.v[885] = target[892]-work.L[1395]*work.v[760]-work.L[1396]*work.v[761]-work.L[1397]*work.v[879]-work.L[1398]*work.v[880]-work.L[1399]*work.v[882]-work.L[1400]*work.v[884];
work.v[886] = target[123]-work.L[1401]*work.v[394]-work.L[1402]*work.v[395]-work.L[1403]*work.v[498]-work.L[1404]*work.v[499]-work.L[1405]*work.v[502]-work.L[1406]*work.v[503]-work.L[1407]*work.v[880]-work.L[1408]*work.v[881]-work.L[1409]*work.v[882]-work.L[1410]*work.v[884]-work.L[1411]*work.v[885];
work.v[887] = target[894];
work.v[888] = target[189]-work.L[1412]*work.v[707]-work.L[1413]*work.v[708]-work.L[1414]*work.v[881]-work.L[1415]*work.v[882]-work.L[1416]*work.v[883]-work.L[1417]*work.v[884]-work.L[1418]*work.v[885]-work.L[1419]*work.v[886]-work.L[1420]*work.v[887];
work.v[889] = target[896];
work.v[890] = target[191]-work.L[1421]*work.v[606]-work.L[1422]*work.v[607]-work.L[1423]*work.v[883]-work.L[1424]*work.v[884]-work.L[1425]*work.v[885]-work.L[1426]*work.v[886]-work.L[1427]*work.v[888]-work.L[1428]*work.v[889];
work.v[891] = target[895]-work.L[1429]*work.v[761]-work.L[1430]*work.v[762]-work.L[1431]*work.v[885]-work.L[1432]*work.v[886]-work.L[1433]*work.v[888]-work.L[1434]*work.v[890];
work.v[892] = target[124]-work.L[1435]*work.v[398]-work.L[1436]*work.v[399]-work.L[1437]*work.v[502]-work.L[1438]*work.v[503]-work.L[1439]*work.v[506]-work.L[1440]*work.v[507]-work.L[1441]*work.v[886]-work.L[1442]*work.v[887]-work.L[1443]*work.v[888]-work.L[1444]*work.v[890]-work.L[1445]*work.v[891];
work.v[893] = target[897];
work.v[894] = target[192]-work.L[1446]*work.v[711]-work.L[1447]*work.v[712]-work.L[1448]*work.v[887]-work.L[1449]*work.v[888]-work.L[1450]*work.v[889]-work.L[1451]*work.v[890]-work.L[1452]*work.v[891]-work.L[1453]*work.v[892]-work.L[1454]*work.v[893];
work.v[895] = target[899];
work.v[896] = target[194]-work.L[1455]*work.v[610]-work.L[1456]*work.v[611]-work.L[1457]*work.v[889]-work.L[1458]*work.v[890]-work.L[1459]*work.v[891]-work.L[1460]*work.v[892]-work.L[1461]*work.v[894]-work.L[1462]*work.v[895];
work.v[897] = target[898]-work.L[1463]*work.v[762]-work.L[1464]*work.v[763]-work.L[1465]*work.v[891]-work.L[1466]*work.v[892]-work.L[1467]*work.v[894]-work.L[1468]*work.v[896];
work.v[898] = target[125]-work.L[1469]*work.v[402]-work.L[1470]*work.v[403]-work.L[1471]*work.v[506]-work.L[1472]*work.v[507]-work.L[1473]*work.v[510]-work.L[1474]*work.v[511]-work.L[1475]*work.v[892]-work.L[1476]*work.v[893]-work.L[1477]*work.v[894]-work.L[1478]*work.v[896]-work.L[1479]*work.v[897];
work.v[899] = target[900];
work.v[900] = target[195]-work.L[1480]*work.v[715]-work.L[1481]*work.v[716]-work.L[1482]*work.v[893]-work.L[1483]*work.v[894]-work.L[1484]*work.v[895]-work.L[1485]*work.v[896]-work.L[1486]*work.v[897]-work.L[1487]*work.v[898]-work.L[1488]*work.v[899];
work.v[901] = target[126]-work.L[1489]*work.v[406]-work.L[1490]*work.v[407]-work.L[1491]*work.v[510]-work.L[1492]*work.v[511]-work.L[1493]*work.v[514]-work.L[1494]*work.v[515]-work.L[1495]*work.v[898]-work.L[1496]*work.v[899]-work.L[1497]*work.v[900];
work.v[902] = target[203]-work.L[1498]*work.v[622]-work.L[1499]*work.v[623]-work.L[1500]*work.v[738]-work.L[1501]*work.v[739]-work.L[1502]*work.v[765]-work.L[1503]*work.v[773]-work.L[1504]*work.v[775]-work.L[1505]*work.v[776];
work.v[903] = target[201]-work.L[1506]*work.v[723]-work.L[1507]*work.v[724]-work.L[1508]*work.v[771]-work.L[1509]*work.v[772]-work.L[1510]*work.v[773]-work.L[1511]*work.v[774]-work.L[1512]*work.v[775]-work.L[1513]*work.v[902];
work.v[904] = target[127]-work.L[1514]*work.v[410]-work.L[1515]*work.v[411]-work.L[1516]*work.v[514]-work.L[1517]*work.v[515]-work.L[1518]*work.v[518]-work.L[1519]*work.v[519]-work.L[1520]*work.v[772]-work.L[1521]*work.v[773]-work.L[1522]*work.v[774]-work.L[1523]*work.v[901]-work.L[1524]*work.v[902]-work.L[1525]*work.v[903];
work.v[905] = target[901]-work.L[1526]*work.v[763]-work.L[1527]*work.v[764]-work.L[1528]*work.v[776]-work.L[1529]*work.v[897]-work.L[1530]*work.v[898]-work.L[1531]*work.v[900]-work.L[1532]*work.v[901]-work.L[1533]*work.v[902]-work.L[1534]*work.v[903]-work.L[1535]*work.v[904];
work.v[906] = target[902];
work.v[907] = target[197]-work.L[1536]*work.v[614]-work.L[1537]*work.v[615]-work.L[1538]*work.v[895]-work.L[1539]*work.v[896]-work.L[1540]*work.v[897]-work.L[1541]*work.v[898]-work.L[1542]*work.v[900]-work.L[1543]*work.v[901]-work.L[1544]*work.v[904]-work.L[1545]*work.v[905]-work.L[1546]*work.v[906];
work.v[908] = target[198]-work.L[1547]*work.v[719]-work.L[1548]*work.v[720]-work.L[1549]*work.v[774]-work.L[1550]*work.v[899]-work.L[1551]*work.v[900]-work.L[1552]*work.v[901]-work.L[1553]*work.v[903]-work.L[1554]*work.v[904]-work.L[1555]*work.v[905]-work.L[1556]*work.v[906]-work.L[1557]*work.v[907];
work.v[909] = target[200]-work.L[1558]*work.v[618]-work.L[1559]*work.v[619]-work.L[1560]*work.v[775]-work.L[1561]*work.v[776]-work.L[1562]*work.v[902]-work.L[1563]*work.v[903]-work.L[1564]*work.v[904]-work.L[1565]*work.v[905]-work.L[1566]*work.v[906]-work.L[1567]*work.v[907]-work.L[1568]*work.v[908];
/* Diagonal scaling. Assume correctness of work.d_inv. */
for (i = 0; i < 910; i++)
work.v[i] *= work.d_inv[i];
/* Back substitution */
work.v[908] -= work.L[1568]*work.v[909];
work.v[907] -= work.L[1557]*work.v[908]+work.L[1567]*work.v[909];
work.v[906] -= work.L[1546]*work.v[907]+work.L[1556]*work.v[908]+work.L[1566]*work.v[909];
work.v[905] -= work.L[1545]*work.v[907]+work.L[1555]*work.v[908]+work.L[1565]*work.v[909];
work.v[904] -= work.L[1535]*work.v[905]+work.L[1544]*work.v[907]+work.L[1554]*work.v[908]+work.L[1564]*work.v[909];
work.v[903] -= work.L[1525]*work.v[904]+work.L[1534]*work.v[905]+work.L[1553]*work.v[908]+work.L[1563]*work.v[909];
work.v[902] -= work.L[1513]*work.v[903]+work.L[1524]*work.v[904]+work.L[1533]*work.v[905]+work.L[1562]*work.v[909];
work.v[901] -= work.L[1523]*work.v[904]+work.L[1532]*work.v[905]+work.L[1543]*work.v[907]+work.L[1552]*work.v[908];
work.v[900] -= work.L[1497]*work.v[901]+work.L[1531]*work.v[905]+work.L[1542]*work.v[907]+work.L[1551]*work.v[908];
work.v[899] -= work.L[1488]*work.v[900]+work.L[1496]*work.v[901]+work.L[1550]*work.v[908];
work.v[898] -= work.L[1487]*work.v[900]+work.L[1495]*work.v[901]+work.L[1530]*work.v[905]+work.L[1541]*work.v[907];
work.v[897] -= work.L[1479]*work.v[898]+work.L[1486]*work.v[900]+work.L[1529]*work.v[905]+work.L[1540]*work.v[907];
work.v[896] -= work.L[1468]*work.v[897]+work.L[1478]*work.v[898]+work.L[1485]*work.v[900]+work.L[1539]*work.v[907];
work.v[895] -= work.L[1462]*work.v[896]+work.L[1484]*work.v[900]+work.L[1538]*work.v[907];
work.v[894] -= work.L[1461]*work.v[896]+work.L[1467]*work.v[897]+work.L[1477]*work.v[898]+work.L[1483]*work.v[900];
work.v[893] -= work.L[1454]*work.v[894]+work.L[1476]*work.v[898]+work.L[1482]*work.v[900];
work.v[892] -= work.L[1453]*work.v[894]+work.L[1460]*work.v[896]+work.L[1466]*work.v[897]+work.L[1475]*work.v[898];
work.v[891] -= work.L[1445]*work.v[892]+work.L[1452]*work.v[894]+work.L[1459]*work.v[896]+work.L[1465]*work.v[897];
work.v[890] -= work.L[1434]*work.v[891]+work.L[1444]*work.v[892]+work.L[1451]*work.v[894]+work.L[1458]*work.v[896];
work.v[889] -= work.L[1428]*work.v[890]+work.L[1450]*work.v[894]+work.L[1457]*work.v[896];
work.v[888] -= work.L[1427]*work.v[890]+work.L[1433]*work.v[891]+work.L[1443]*work.v[892]+work.L[1449]*work.v[894];
work.v[887] -= work.L[1420]*work.v[888]+work.L[1442]*work.v[892]+work.L[1448]*work.v[894];
work.v[886] -= work.L[1419]*work.v[888]+work.L[1426]*work.v[890]+work.L[1432]*work.v[891]+work.L[1441]*work.v[892];
work.v[885] -= work.L[1411]*work.v[886]+work.L[1418]*work.v[888]+work.L[1425]*work.v[890]+work.L[1431]*work.v[891];
work.v[884] -= work.L[1400]*work.v[885]+work.L[1410]*work.v[886]+work.L[1417]*work.v[888]+work.L[1424]*work.v[890];
work.v[883] -= work.L[1394]*work.v[884]+work.L[1416]*work.v[888]+work.L[1423]*work.v[890];
work.v[882] -= work.L[1393]*work.v[884]+work.L[1399]*work.v[885]+work.L[1409]*work.v[886]+work.L[1415]*work.v[888];
work.v[881] -= work.L[1386]*work.v[882]+work.L[1408]*work.v[886]+work.L[1414]*work.v[888];
work.v[880] -= work.L[1385]*work.v[882]+work.L[1392]*work.v[884]+work.L[1398]*work.v[885]+work.L[1407]*work.v[886];
work.v[879] -= work.L[1377]*work.v[880]+work.L[1384]*work.v[882]+work.L[1391]*work.v[884]+work.L[1397]*work.v[885];
work.v[878] -= work.L[1366]*work.v[879]+work.L[1376]*work.v[880]+work.L[1383]*work.v[882]+work.L[1390]*work.v[884];
work.v[877] -= work.L[1360]*work.v[878]+work.L[1382]*work.v[882]+work.L[1389]*work.v[884];
work.v[876] -= work.L[1359]*work.v[878]+work.L[1365]*work.v[879]+work.L[1375]*work.v[880]+work.L[1381]*work.v[882];
work.v[875] -= work.L[1352]*work.v[876]+work.L[1374]*work.v[880]+work.L[1380]*work.v[882];
work.v[874] -= work.L[1351]*work.v[876]+work.L[1358]*work.v[878]+work.L[1364]*work.v[879]+work.L[1373]*work.v[880];
work.v[873] -= work.L[1343]*work.v[874]+work.L[1350]*work.v[876]+work.L[1357]*work.v[878]+work.L[1363]*work.v[879];
work.v[872] -= work.L[1332]*work.v[873]+work.L[1342]*work.v[874]+work.L[1349]*work.v[876]+work.L[1356]*work.v[878];
work.v[871] -= work.L[1326]*work.v[872]+work.L[1348]*work.v[876]+work.L[1355]*work.v[878];
work.v[870] -= work.L[1325]*work.v[872]+work.L[1331]*work.v[873]+work.L[1341]*work.v[874]+work.L[1347]*work.v[876];
work.v[869] -= work.L[1318]*work.v[870]+work.L[1340]*work.v[874]+work.L[1346]*work.v[876];
work.v[868] -= work.L[1317]*work.v[870]+work.L[1324]*work.v[872]+work.L[1330]*work.v[873]+work.L[1339]*work.v[874];
work.v[867] -= work.L[1309]*work.v[868]+work.L[1316]*work.v[870]+work.L[1323]*work.v[872]+work.L[1329]*work.v[873];
work.v[866] -= work.L[1298]*work.v[867]+work.L[1308]*work.v[868]+work.L[1315]*work.v[870]+work.L[1322]*work.v[872];
work.v[865] -= work.L[1292]*work.v[866]+work.L[1314]*work.v[870]+work.L[1321]*work.v[872];
work.v[864] -= work.L[1291]*work.v[866]+work.L[1297]*work.v[867]+work.L[1307]*work.v[868]+work.L[1313]*work.v[870];
work.v[863] -= work.L[1284]*work.v[864]+work.L[1306]*work.v[868]+work.L[1312]*work.v[870];
work.v[862] -= work.L[1283]*work.v[864]+work.L[1290]*work.v[866]+work.L[1296]*work.v[867]+work.L[1305]*work.v[868];
work.v[861] -= work.L[1275]*work.v[862]+work.L[1282]*work.v[864]+work.L[1289]*work.v[866]+work.L[1295]*work.v[867];
work.v[860] -= work.L[1264]*work.v[861]+work.L[1274]*work.v[862]+work.L[1281]*work.v[864]+work.L[1288]*work.v[866];
work.v[859] -= work.L[1258]*work.v[860]+work.L[1280]*work.v[864]+work.L[1287]*work.v[866];
work.v[858] -= work.L[1257]*work.v[860]+work.L[1263]*work.v[861]+work.L[1273]*work.v[862]+work.L[1279]*work.v[864];
work.v[857] -= work.L[1250]*work.v[858]+work.L[1272]*work.v[862]+work.L[1278]*work.v[864];
work.v[856] -= work.L[1249]*work.v[858]+work.L[1256]*work.v[860]+work.L[1262]*work.v[861]+work.L[1271]*work.v[862];
work.v[855] -= work.L[1241]*work.v[856]+work.L[1248]*work.v[858]+work.L[1255]*work.v[860]+work.L[1261]*work.v[861];
work.v[854] -= work.L[1230]*work.v[855]+work.L[1240]*work.v[856]+work.L[1247]*work.v[858]+work.L[1254]*work.v[860];
work.v[853] -= work.L[1224]*work.v[854]+work.L[1246]*work.v[858]+work.L[1253]*work.v[860];
work.v[852] -= work.L[1223]*work.v[854]+work.L[1229]*work.v[855]+work.L[1239]*work.v[856]+work.L[1245]*work.v[858];
work.v[851] -= work.L[1216]*work.v[852]+work.L[1238]*work.v[856]+work.L[1244]*work.v[858];
work.v[850] -= work.L[1215]*work.v[852]+work.L[1222]*work.v[854]+work.L[1228]*work.v[855]+work.L[1237]*work.v[856];
work.v[849] -= work.L[1207]*work.v[850]+work.L[1214]*work.v[852]+work.L[1221]*work.v[854]+work.L[1227]*work.v[855];
work.v[848] -= work.L[1196]*work.v[849]+work.L[1206]*work.v[850]+work.L[1213]*work.v[852]+work.L[1220]*work.v[854];
work.v[847] -= work.L[1190]*work.v[848]+work.L[1212]*work.v[852]+work.L[1219]*work.v[854];
work.v[846] -= work.L[1189]*work.v[848]+work.L[1195]*work.v[849]+work.L[1205]*work.v[850]+work.L[1211]*work.v[852];
work.v[845] -= work.L[1182]*work.v[846]+work.L[1204]*work.v[850]+work.L[1210]*work.v[852];
work.v[844] -= work.L[1181]*work.v[846]+work.L[1188]*work.v[848]+work.L[1194]*work.v[849]+work.L[1203]*work.v[850];
work.v[843] -= work.L[1173]*work.v[844]+work.L[1180]*work.v[846]+work.L[1187]*work.v[848]+work.L[1193]*work.v[849];
work.v[842] -= work.L[1162]*work.v[843]+work.L[1172]*work.v[844]+work.L[1179]*work.v[846]+work.L[1186]*work.v[848];
work.v[841] -= work.L[1156]*work.v[842]+work.L[1178]*work.v[846]+work.L[1185]*work.v[848];
work.v[840] -= work.L[1155]*work.v[842]+work.L[1161]*work.v[843]+work.L[1171]*work.v[844]+work.L[1177]*work.v[846];
work.v[839] -= work.L[1148]*work.v[840]+work.L[1170]*work.v[844]+work.L[1176]*work.v[846];
work.v[838] -= work.L[1147]*work.v[840]+work.L[1154]*work.v[842]+work.L[1160]*work.v[843]+work.L[1169]*work.v[844];
work.v[837] -= work.L[1139]*work.v[838]+work.L[1146]*work.v[840]+work.L[1153]*work.v[842]+work.L[1159]*work.v[843];
work.v[836] -= work.L[1128]*work.v[837]+work.L[1138]*work.v[838]+work.L[1145]*work.v[840]+work.L[1152]*work.v[842];
work.v[835] -= work.L[1122]*work.v[836]+work.L[1144]*work.v[840]+work.L[1151]*work.v[842];
work.v[834] -= work.L[1121]*work.v[836]+work.L[1127]*work.v[837]+work.L[1137]*work.v[838]+work.L[1143]*work.v[840];
work.v[833] -= work.L[1114]*work.v[834]+work.L[1136]*work.v[838]+work.L[1142]*work.v[840];
work.v[832] -= work.L[1113]*work.v[834]+work.L[1120]*work.v[836]+work.L[1126]*work.v[837]+work.L[1135]*work.v[838];
work.v[831] -= work.L[1105]*work.v[832]+work.L[1112]*work.v[834]+work.L[1119]*work.v[836]+work.L[1125]*work.v[837];
work.v[830] -= work.L[1094]*work.v[831]+work.L[1104]*work.v[832]+work.L[1111]*work.v[834]+work.L[1118]*work.v[836];
work.v[829] -= work.L[1088]*work.v[830]+work.L[1110]*work.v[834]+work.L[1117]*work.v[836];
work.v[828] -= work.L[1087]*work.v[830]+work.L[1093]*work.v[831]+work.L[1103]*work.v[832]+work.L[1109]*work.v[834];
work.v[827] -= work.L[1080]*work.v[828]+work.L[1102]*work.v[832]+work.L[1108]*work.v[834];
work.v[826] -= work.L[1079]*work.v[828]+work.L[1086]*work.v[830]+work.L[1092]*work.v[831]+work.L[1101]*work.v[832];
work.v[825] -= work.L[1071]*work.v[826]+work.L[1078]*work.v[828]+work.L[1085]*work.v[830]+work.L[1091]*work.v[831];
work.v[824] -= work.L[1060]*work.v[825]+work.L[1070]*work.v[826]+work.L[1077]*work.v[828]+work.L[1084]*work.v[830];
work.v[823] -= work.L[1054]*work.v[824]+work.L[1076]*work.v[828]+work.L[1083]*work.v[830];
work.v[822] -= work.L[1053]*work.v[824]+work.L[1059]*work.v[825]+work.L[1069]*work.v[826]+work.L[1075]*work.v[828];
work.v[821] -= work.L[1046]*work.v[822]+work.L[1068]*work.v[826]+work.L[1074]*work.v[828];
work.v[820] -= work.L[1045]*work.v[822]+work.L[1052]*work.v[824]+work.L[1058]*work.v[825]+work.L[1067]*work.v[826];
work.v[819] -= work.L[1037]*work.v[820]+work.L[1044]*work.v[822]+work.L[1051]*work.v[824]+work.L[1057]*work.v[825];
work.v[818] -= work.L[1026]*work.v[819]+work.L[1036]*work.v[820]+work.L[1043]*work.v[822]+work.L[1050]*work.v[824];
work.v[817] -= work.L[1020]*work.v[818]+work.L[1042]*work.v[822]+work.L[1049]*work.v[824];
work.v[816] -= work.L[1019]*work.v[818]+work.L[1025]*work.v[819]+work.L[1035]*work.v[820]+work.L[1041]*work.v[822];
work.v[815] -= work.L[1012]*work.v[816]+work.L[1034]*work.v[820]+work.L[1040]*work.v[822];
work.v[814] -= work.L[1011]*work.v[816]+work.L[1018]*work.v[818]+work.L[1024]*work.v[819]+work.L[1033]*work.v[820];
work.v[813] -= work.L[1003]*work.v[814]+work.L[1010]*work.v[816]+work.L[1017]*work.v[818]+work.L[1023]*work.v[819];
work.v[812] -= work.L[992]*work.v[813]+work.L[1002]*work.v[814]+work.L[1009]*work.v[816]+work.L[1016]*work.v[818];
work.v[811] -= work.L[986]*work.v[812]+work.L[1008]*work.v[816]+work.L[1015]*work.v[818];
work.v[810] -= work.L[985]*work.v[812]+work.L[991]*work.v[813]+work.L[1001]*work.v[814]+work.L[1007]*work.v[816];
work.v[809] -= work.L[978]*work.v[810]+work.L[1000]*work.v[814]+work.L[1006]*work.v[816];
work.v[808] -= work.L[977]*work.v[810]+work.L[984]*work.v[812]+work.L[990]*work.v[813]+work.L[999]*work.v[814];
work.v[807] -= work.L[969]*work.v[808]+work.L[976]*work.v[810]+work.L[983]*work.v[812]+work.L[989]*work.v[813];
work.v[806] -= work.L[958]*work.v[807]+work.L[968]*work.v[808]+work.L[975]*work.v[810]+work.L[982]*work.v[812];
work.v[805] -= work.L[952]*work.v[806]+work.L[974]*work.v[810]+work.L[981]*work.v[812];
work.v[804] -= work.L[951]*work.v[806]+work.L[957]*work.v[807]+work.L[967]*work.v[808]+work.L[973]*work.v[810];
work.v[803] -= work.L[944]*work.v[804]+work.L[966]*work.v[808]+work.L[972]*work.v[810];
work.v[802] -= work.L[943]*work.v[804]+work.L[950]*work.v[806]+work.L[956]*work.v[807]+work.L[965]*work.v[808];
work.v[801] -= work.L[935]*work.v[802]+work.L[942]*work.v[804]+work.L[949]*work.v[806]+work.L[955]*work.v[807];
work.v[800] -= work.L[924]*work.v[801]+work.L[934]*work.v[802]+work.L[941]*work.v[804]+work.L[948]*work.v[806];
work.v[799] -= work.L[918]*work.v[800]+work.L[940]*work.v[804]+work.L[947]*work.v[806];
work.v[798] -= work.L[917]*work.v[800]+work.L[923]*work.v[801]+work.L[933]*work.v[802]+work.L[939]*work.v[804];
work.v[797] -= work.L[910]*work.v[798]+work.L[932]*work.v[802]+work.L[938]*work.v[804];
work.v[796] -= work.L[909]*work.v[798]+work.L[916]*work.v[800]+work.L[922]*work.v[801]+work.L[931]*work.v[802];
work.v[795] -= work.L[901]*work.v[796]+work.L[908]*work.v[798]+work.L[915]*work.v[800]+work.L[921]*work.v[801];
work.v[794] -= work.L[890]*work.v[795]+work.L[900]*work.v[796]+work.L[907]*work.v[798]+work.L[914]*work.v[800];
work.v[793] -= work.L[884]*work.v[794]+work.L[906]*work.v[798]+work.L[913]*work.v[800];
work.v[792] -= work.L[883]*work.v[794]+work.L[889]*work.v[795]+work.L[899]*work.v[796]+work.L[905]*work.v[798];
work.v[791] -= work.L[876]*work.v[792]+work.L[898]*work.v[796]+work.L[904]*work.v[798];
work.v[790] -= work.L[875]*work.v[792]+work.L[882]*work.v[794]+work.L[888]*work.v[795]+work.L[897]*work.v[796];
work.v[789] -= work.L[867]*work.v[790]+work.L[874]*work.v[792]+work.L[881]*work.v[794]+work.L[887]*work.v[795];
work.v[788] -= work.L[856]*work.v[789]+work.L[866]*work.v[790]+work.L[873]*work.v[792]+work.L[880]*work.v[794];
work.v[787] -= work.L[850]*work.v[788]+work.L[872]*work.v[792]+work.L[879]*work.v[794];
work.v[786] -= work.L[849]*work.v[788]+work.L[855]*work.v[789]+work.L[865]*work.v[790]+work.L[871]*work.v[792];
work.v[785] -= work.L[842]*work.v[786]+work.L[864]*work.v[790]+work.L[870]*work.v[792];
work.v[784] -= work.L[841]*work.v[786]+work.L[848]*work.v[788]+work.L[854]*work.v[789]+work.L[863]*work.v[790];
work.v[783] -= work.L[832]*work.v[784]+work.L[840]*work.v[786]+work.L[847]*work.v[788]+work.L[853]*work.v[789];
work.v[782] -= work.L[819]*work.v[783]+work.L[831]*work.v[784]+work.L[839]*work.v[786]+work.L[846]*work.v[788];
work.v[781] -= work.L[811]*work.v[782]+work.L[838]*work.v[786]+work.L[845]*work.v[788];
work.v[780] -= work.L[810]*work.v[782]+work.L[818]*work.v[783]+work.L[830]*work.v[784]+work.L[837]*work.v[786];
work.v[779] -= work.L[807]*work.v[780]+work.L[817]*work.v[783]+work.L[829]*work.v[784]+work.L[836]*work.v[786];
work.v[778] -= work.L[804]*work.v[779]+work.L[806]*work.v[780]+work.L[816]*work.v[783]+work.L[828]*work.v[784];
work.v[777] -= work.L[798]*work.v[778]+work.L[805]*work.v[780]+work.L[815]*work.v[783];
work.v[776] -= work.L[1505]*work.v[902]+work.L[1528]*work.v[905]+work.L[1561]*work.v[909];
work.v[775] -= work.L[1504]*work.v[902]+work.L[1512]*work.v[903]+work.L[1560]*work.v[909];
work.v[774] -= work.L[1511]*work.v[903]+work.L[1522]*work.v[904]+work.L[1549]*work.v[908];
work.v[773] -= work.L[1503]*work.v[902]+work.L[1510]*work.v[903]+work.L[1521]*work.v[904];
work.v[772] -= work.L[783]*work.v[773]+work.L[1509]*work.v[903]+work.L[1520]*work.v[904];
work.v[771] -= work.L[777]*work.v[772]+work.L[782]*work.v[773]+work.L[1508]*work.v[903];
work.v[770] -= work.L[803]*work.v[779]+work.L[827]*work.v[784]+work.L[835]*work.v[786];
work.v[769] -= work.L[789]*work.v[777]+work.L[797]*work.v[778]+work.L[814]*work.v[783];
work.v[768] -= work.L[796]*work.v[778]+work.L[802]*work.v[779]+work.L[826]*work.v[784];
work.v[767] -= work.L[765]*work.v[768]+work.L[795]*work.v[778]+work.L[801]*work.v[779];
work.v[766] -= work.L[768]*work.v[769]+work.L[788]*work.v[777]+work.L[794]*work.v[778];
work.v[765] -= work.L[785]*work.v[776]+work.L[1502]*work.v[902];
work.v[764] -= work.L[784]*work.v[776]+work.L[1527]*work.v[905];
work.v[763] -= work.L[1464]*work.v[897]+work.L[1526]*work.v[905];
work.v[762] -= work.L[1430]*work.v[891]+work.L[1463]*work.v[897];
work.v[761] -= work.L[1396]*work.v[885]+work.L[1429]*work.v[891];
work.v[760] -= work.L[1362]*work.v[879]+work.L[1395]*work.v[885];
work.v[759] -= work.L[1328]*work.v[873]+work.L[1361]*work.v[879];
work.v[758] -= work.L[1294]*work.v[867]+work.L[1327]*work.v[873];
work.v[757] -= work.L[1260]*work.v[861]+work.L[1293]*work.v[867];
work.v[756] -= work.L[1226]*work.v[855]+work.L[1259]*work.v[861];
work.v[755] -= work.L[1192]*work.v[849]+work.L[1225]*work.v[855];
work.v[754] -= work.L[1158]*work.v[843]+work.L[1191]*work.v[849];
work.v[753] -= work.L[1124]*work.v[837]+work.L[1157]*work.v[843];
work.v[752] -= work.L[1090]*work.v[831]+work.L[1123]*work.v[837];
work.v[751] -= work.L[1056]*work.v[825]+work.L[1089]*work.v[831];
work.v[750] -= work.L[1022]*work.v[819]+work.L[1055]*work.v[825];
work.v[749] -= work.L[988]*work.v[813]+work.L[1021]*work.v[819];
work.v[748] -= work.L[954]*work.v[807]+work.L[987]*work.v[813];
work.v[747] -= work.L[920]*work.v[801]+work.L[953]*work.v[807];
work.v[746] -= work.L[886]*work.v[795]+work.L[919]*work.v[801];
work.v[745] -= work.L[852]*work.v[789]+work.L[885]*work.v[795];
work.v[744] -= work.L[813]*work.v[783]+work.L[851]*work.v[789];
work.v[743] -= work.L[767]*work.v[769]+work.L[812]*work.v[783];
work.v[742] -= work.L[757]*work.v[766]+work.L[766]*work.v[769];
work.v[741] -= work.L[754]*work.v[742]+work.L[756]*work.v[766];
work.v[740] -= work.L[776]*work.v[772]+work.L[781]*work.v[773];
work.v[739] -= work.L[780]*work.v[773]+work.L[1501]*work.v[902];
work.v[738] -= work.L[755]*work.v[765]+work.L[1500]*work.v[902];
work.v[737] -= work.L[752]*work.v[741]+work.L[753]*work.v[742];
work.v[736] -= work.L[764]*work.v[768]+work.L[793]*work.v[778];
work.v[735] -= work.L[743]*work.v[736]+work.L[792]*work.v[778];
work.v[734] -= work.L[748]*work.v[740]+work.L[775]*work.v[772];
work.v[733] -= work.L[747]*work.v[740];
work.v[732] -= work.L[732]*work.v[733];
work.v[731] -= work.L[730]*work.v[732]+work.L[731]*work.v[733];
work.v[730] -= work.L[727]*work.v[731]+work.L[729]*work.v[732];
work.v[729] -= work.L[725]*work.v[730];
work.v[728] -= work.L[779]*work.v[773];
work.v[727] -= work.L[723]*work.v[728]+work.L[778]*work.v[773];
work.v[726] -= work.L[720]*work.v[727]+work.L[722]*work.v[728];
work.v[725] -= work.L[718]*work.v[726];
work.v[724] -= work.L[1507]*work.v[903];
work.v[723] -= work.L[716]*work.v[724]+work.L[1506]*work.v[903];
work.v[722] -= work.L[713]*work.v[723]+work.L[715]*work.v[724];
work.v[721] -= work.L[711]*work.v[722];
work.v[720] -= work.L[1548]*work.v[908];
work.v[719] -= work.L[709]*work.v[720]+work.L[1547]*work.v[908];
work.v[718] -= work.L[706]*work.v[719]+work.L[708]*work.v[720];
work.v[717] -= work.L[704]*work.v[718];
work.v[716] -= work.L[1481]*work.v[900];
work.v[715] -= work.L[702]*work.v[716]+work.L[1480]*work.v[900];
work.v[714] -= work.L[699]*work.v[715]+work.L[701]*work.v[716];
work.v[713] -= work.L[697]*work.v[714];
work.v[712] -= work.L[1447]*work.v[894];
work.v[711] -= work.L[695]*work.v[712]+work.L[1446]*work.v[894];
work.v[710] -= work.L[692]*work.v[711]+work.L[694]*work.v[712];
work.v[709] -= work.L[690]*work.v[710];
work.v[708] -= work.L[1413]*work.v[888];
work.v[707] -= work.L[688]*work.v[708]+work.L[1412]*work.v[888];
work.v[706] -= work.L[685]*work.v[707]+work.L[687]*work.v[708];
work.v[705] -= work.L[683]*work.v[706];
work.v[704] -= work.L[1379]*work.v[882];
work.v[703] -= work.L[681]*work.v[704]+work.L[1378]*work.v[882];
work.v[702] -= work.L[678]*work.v[703]+work.L[680]*work.v[704];
work.v[701] -= work.L[676]*work.v[702];
work.v[700] -= work.L[1345]*work.v[876];
work.v[699] -= work.L[674]*work.v[700]+work.L[1344]*work.v[876];
work.v[698] -= work.L[671]*work.v[699]+work.L[673]*work.v[700];
work.v[697] -= work.L[669]*work.v[698];
work.v[696] -= work.L[1311]*work.v[870];
work.v[695] -= work.L[667]*work.v[696]+work.L[1310]*work.v[870];
work.v[694] -= work.L[664]*work.v[695]+work.L[666]*work.v[696];
work.v[693] -= work.L[662]*work.v[694];
work.v[692] -= work.L[1277]*work.v[864];
work.v[691] -= work.L[660]*work.v[692]+work.L[1276]*work.v[864];
work.v[690] -= work.L[657]*work.v[691]+work.L[659]*work.v[692];
work.v[689] -= work.L[655]*work.v[690];
work.v[688] -= work.L[1243]*work.v[858];
work.v[687] -= work.L[653]*work.v[688]+work.L[1242]*work.v[858];
work.v[686] -= work.L[650]*work.v[687]+work.L[652]*work.v[688];
work.v[685] -= work.L[648]*work.v[686];
work.v[684] -= work.L[1209]*work.v[852];
work.v[683] -= work.L[646]*work.v[684]+work.L[1208]*work.v[852];
work.v[682] -= work.L[643]*work.v[683]+work.L[645]*work.v[684];
work.v[681] -= work.L[641]*work.v[682];
work.v[680] -= work.L[1175]*work.v[846];
work.v[679] -= work.L[639]*work.v[680]+work.L[1174]*work.v[846];
work.v[678] -= work.L[636]*work.v[679]+work.L[638]*work.v[680];
work.v[677] -= work.L[634]*work.v[678];
work.v[676] -= work.L[1141]*work.v[840];
work.v[675] -= work.L[632]*work.v[676]+work.L[1140]*work.v[840];
work.v[674] -= work.L[629]*work.v[675]+work.L[631]*work.v[676];
work.v[673] -= work.L[627]*work.v[674];
work.v[672] -= work.L[1107]*work.v[834];
work.v[671] -= work.L[625]*work.v[672]+work.L[1106]*work.v[834];
work.v[670] -= work.L[622]*work.v[671]+work.L[624]*work.v[672];
work.v[669] -= work.L[620]*work.v[670];
work.v[668] -= work.L[1073]*work.v[828];
work.v[667] -= work.L[618]*work.v[668]+work.L[1072]*work.v[828];
work.v[666] -= work.L[615]*work.v[667]+work.L[617]*work.v[668];
work.v[665] -= work.L[613]*work.v[666];
work.v[664] -= work.L[1039]*work.v[822];
work.v[663] -= work.L[611]*work.v[664]+work.L[1038]*work.v[822];
work.v[662] -= work.L[608]*work.v[663]+work.L[610]*work.v[664];
work.v[661] -= work.L[606]*work.v[662];
work.v[660] -= work.L[1005]*work.v[816];
work.v[659] -= work.L[604]*work.v[660]+work.L[1004]*work.v[816];
work.v[658] -= work.L[601]*work.v[659]+work.L[603]*work.v[660];
work.v[657] -= work.L[599]*work.v[658];
work.v[656] -= work.L[971]*work.v[810];
work.v[655] -= work.L[597]*work.v[656]+work.L[970]*work.v[810];
work.v[654] -= work.L[594]*work.v[655]+work.L[596]*work.v[656];
work.v[653] -= work.L[592]*work.v[654];
work.v[652] -= work.L[937]*work.v[804];
work.v[651] -= work.L[590]*work.v[652]+work.L[936]*work.v[804];
work.v[650] -= work.L[587]*work.v[651]+work.L[589]*work.v[652];
work.v[649] -= work.L[585]*work.v[650];
work.v[648] -= work.L[903]*work.v[798];
work.v[647] -= work.L[583]*work.v[648]+work.L[902]*work.v[798];
work.v[646] -= work.L[580]*work.v[647]+work.L[582]*work.v[648];
work.v[645] -= work.L[578]*work.v[646];
work.v[644] -= work.L[869]*work.v[792];
work.v[643] -= work.L[576]*work.v[644]+work.L[868]*work.v[792];
work.v[642] -= work.L[573]*work.v[643]+work.L[575]*work.v[644];
work.v[641] -= work.L[571]*work.v[642];
work.v[640] -= work.L[834]*work.v[786];
work.v[639] -= work.L[569]*work.v[640]+work.L[833]*work.v[786];
work.v[638] -= work.L[566]*work.v[639]+work.L[568]*work.v[640];
work.v[637] -= work.L[564]*work.v[638];
work.v[636] -= work.L[800]*work.v[779];
work.v[635] -= work.L[562]*work.v[636]+work.L[799]*work.v[779];
work.v[634] -= work.L[559]*work.v[635]+work.L[561]*work.v[636];
work.v[633] -= work.L[557]*work.v[634];
work.v[632] -= work.L[791]*work.v[778];
work.v[631] -= work.L[555]*work.v[632]+work.L[790]*work.v[778];
work.v[630] -= work.L[552]*work.v[631]+work.L[554]*work.v[632];
work.v[629] -= work.L[550]*work.v[630];
work.v[628] -= work.L[746]*work.v[739];
work.v[627] -= work.L[548]*work.v[628];
work.v[626] -= work.L[546]*work.v[627]+work.L[547]*work.v[628];
work.v[625] -= work.L[543]*work.v[626]+work.L[545]*work.v[627];
work.v[624] -= work.L[541]*work.v[625];
work.v[623] -= work.L[1499]*work.v[902];
work.v[622] -= work.L[539]*work.v[623]+work.L[1498]*work.v[902];
work.v[621] -= work.L[536]*work.v[622]+work.L[538]*work.v[623];
work.v[620] -= work.L[534]*work.v[621];
work.v[619] -= work.L[1559]*work.v[909];
work.v[618] -= work.L[532]*work.v[619]+work.L[1558]*work.v[909];
work.v[617] -= work.L[529]*work.v[618]+work.L[531]*work.v[619];
work.v[616] -= work.L[527]*work.v[617];
work.v[615] -= work.L[1537]*work.v[907];
work.v[614] -= work.L[525]*work.v[615]+work.L[1536]*work.v[907];
work.v[613] -= work.L[522]*work.v[614]+work.L[524]*work.v[615];
work.v[612] -= work.L[520]*work.v[613];
work.v[611] -= work.L[1456]*work.v[896];
work.v[610] -= work.L[518]*work.v[611]+work.L[1455]*work.v[896];
work.v[609] -= work.L[515]*work.v[610]+work.L[517]*work.v[611];
work.v[608] -= work.L[513]*work.v[609];
work.v[607] -= work.L[1422]*work.v[890];
work.v[606] -= work.L[511]*work.v[607]+work.L[1421]*work.v[890];
work.v[605] -= work.L[508]*work.v[606]+work.L[510]*work.v[607];
work.v[604] -= work.L[506]*work.v[605];
work.v[603] -= work.L[1388]*work.v[884];
work.v[602] -= work.L[504]*work.v[603]+work.L[1387]*work.v[884];
work.v[601] -= work.L[501]*work.v[602]+work.L[503]*work.v[603];
work.v[600] -= work.L[499]*work.v[601];
work.v[599] -= work.L[1354]*work.v[878];
work.v[598] -= work.L[497]*work.v[599]+work.L[1353]*work.v[878];
work.v[597] -= work.L[494]*work.v[598]+work.L[496]*work.v[599];
work.v[596] -= work.L[492]*work.v[597];
work.v[595] -= work.L[1320]*work.v[872];
work.v[594] -= work.L[490]*work.v[595]+work.L[1319]*work.v[872];
work.v[593] -= work.L[487]*work.v[594]+work.L[489]*work.v[595];
work.v[592] -= work.L[485]*work.v[593];
work.v[591] -= work.L[1286]*work.v[866];
work.v[590] -= work.L[483]*work.v[591]+work.L[1285]*work.v[866];
work.v[589] -= work.L[480]*work.v[590]+work.L[482]*work.v[591];
work.v[588] -= work.L[478]*work.v[589];
work.v[587] -= work.L[1252]*work.v[860];
work.v[586] -= work.L[476]*work.v[587]+work.L[1251]*work.v[860];
work.v[585] -= work.L[473]*work.v[586]+work.L[475]*work.v[587];
work.v[584] -= work.L[471]*work.v[585];
work.v[583] -= work.L[1218]*work.v[854];
work.v[582] -= work.L[469]*work.v[583]+work.L[1217]*work.v[854];
work.v[581] -= work.L[466]*work.v[582]+work.L[468]*work.v[583];
work.v[580] -= work.L[464]*work.v[581];
work.v[579] -= work.L[1184]*work.v[848];
work.v[578] -= work.L[462]*work.v[579]+work.L[1183]*work.v[848];
work.v[577] -= work.L[459]*work.v[578]+work.L[461]*work.v[579];
work.v[576] -= work.L[457]*work.v[577];
work.v[575] -= work.L[1150]*work.v[842];
work.v[574] -= work.L[455]*work.v[575]+work.L[1149]*work.v[842];
work.v[573] -= work.L[452]*work.v[574]+work.L[454]*work.v[575];
work.v[572] -= work.L[450]*work.v[573];
work.v[571] -= work.L[1116]*work.v[836];
work.v[570] -= work.L[448]*work.v[571]+work.L[1115]*work.v[836];
work.v[569] -= work.L[445]*work.v[570]+work.L[447]*work.v[571];
work.v[568] -= work.L[443]*work.v[569];
work.v[567] -= work.L[1082]*work.v[830];
work.v[566] -= work.L[441]*work.v[567]+work.L[1081]*work.v[830];
work.v[565] -= work.L[438]*work.v[566]+work.L[440]*work.v[567];
work.v[564] -= work.L[436]*work.v[565];
work.v[563] -= work.L[1048]*work.v[824];
work.v[562] -= work.L[434]*work.v[563]+work.L[1047]*work.v[824];
work.v[561] -= work.L[431]*work.v[562]+work.L[433]*work.v[563];
work.v[560] -= work.L[429]*work.v[561];
work.v[559] -= work.L[1014]*work.v[818];
work.v[558] -= work.L[427]*work.v[559]+work.L[1013]*work.v[818];
work.v[557] -= work.L[424]*work.v[558]+work.L[426]*work.v[559];
work.v[556] -= work.L[422]*work.v[557];
work.v[555] -= work.L[980]*work.v[812];
work.v[554] -= work.L[420]*work.v[555]+work.L[979]*work.v[812];
work.v[553] -= work.L[417]*work.v[554]+work.L[419]*work.v[555];
work.v[552] -= work.L[415]*work.v[553];
work.v[551] -= work.L[946]*work.v[806];
work.v[550] -= work.L[413]*work.v[551]+work.L[945]*work.v[806];
work.v[549] -= work.L[410]*work.v[550]+work.L[412]*work.v[551];
work.v[548] -= work.L[408]*work.v[549];
work.v[547] -= work.L[912]*work.v[800];
work.v[546] -= work.L[406]*work.v[547]+work.L[911]*work.v[800];
work.v[545] -= work.L[403]*work.v[546]+work.L[405]*work.v[547];
work.v[544] -= work.L[401]*work.v[545];
work.v[543] -= work.L[878]*work.v[794];
work.v[542] -= work.L[399]*work.v[543]+work.L[877]*work.v[794];
work.v[541] -= work.L[396]*work.v[542]+work.L[398]*work.v[543];
work.v[540] -= work.L[394]*work.v[541];
work.v[539] -= work.L[844]*work.v[788];
work.v[538] -= work.L[392]*work.v[539]+work.L[843]*work.v[788];
work.v[537] -= work.L[389]*work.v[538]+work.L[391]*work.v[539];
work.v[536] -= work.L[387]*work.v[537];
work.v[535] -= work.L[809]*work.v[782];
work.v[534] -= work.L[385]*work.v[535]+work.L[808]*work.v[782];
work.v[533] -= work.L[382]*work.v[534]+work.L[384]*work.v[535];
work.v[532] -= work.L[380]*work.v[533];
work.v[531] -= work.L[787]*work.v[777];
work.v[530] -= work.L[378]*work.v[531]+work.L[786]*work.v[777];
work.v[529] -= work.L[375]*work.v[530]+work.L[377]*work.v[531];
work.v[528] -= work.L[373]*work.v[529];
work.v[527] -= work.L[751]*work.v[741];
work.v[526] -= work.L[371]*work.v[527]+work.L[750]*work.v[741];
work.v[525] -= work.L[368]*work.v[526]+work.L[370]*work.v[527];
work.v[524] -= work.L[366]*work.v[525];
work.v[523] -= work.L[736]*work.v[734]+work.L[774]*work.v[772];
work.v[522] -= work.L[364]*work.v[523]+work.L[735]*work.v[734]+work.L[773]*work.v[772];
work.v[521] -= work.L[361]*work.v[522]+work.L[363]*work.v[523];
work.v[520] -= work.L[359]*work.v[521];
work.v[519] -= work.L[772]*work.v[772]+work.L[1519]*work.v[904];
work.v[518] -= work.L[357]*work.v[519]+work.L[771]*work.v[772]+work.L[1518]*work.v[904];
work.v[517] -= work.L[354]*work.v[518]+work.L[356]*work.v[519];
work.v[516] -= work.L[352]*work.v[517];
work.v[515] -= work.L[1494]*work.v[901]+work.L[1517]*work.v[904];
work.v[514] -= work.L[350]*work.v[515]+work.L[1493]*work.v[901]+work.L[1516]*work.v[904];
work.v[513] -= work.L[347]*work.v[514]+work.L[349]*work.v[515];
work.v[512] -= work.L[345]*work.v[513];
work.v[511] -= work.L[1474]*work.v[898]+work.L[1492]*work.v[901];
work.v[510] -= work.L[343]*work.v[511]+work.L[1473]*work.v[898]+work.L[1491]*work.v[901];
work.v[509] -= work.L[340]*work.v[510]+work.L[342]*work.v[511];
work.v[508] -= work.L[338]*work.v[509];
work.v[507] -= work.L[1440]*work.v[892]+work.L[1472]*work.v[898];
work.v[506] -= work.L[336]*work.v[507]+work.L[1439]*work.v[892]+work.L[1471]*work.v[898];
work.v[505] -= work.L[333]*work.v[506]+work.L[335]*work.v[507];
work.v[504] -= work.L[331]*work.v[505];
work.v[503] -= work.L[1406]*work.v[886]+work.L[1438]*work.v[892];
work.v[502] -= work.L[329]*work.v[503]+work.L[1405]*work.v[886]+work.L[1437]*work.v[892];
work.v[501] -= work.L[326]*work.v[502]+work.L[328]*work.v[503];
work.v[500] -= work.L[324]*work.v[501];
work.v[499] -= work.L[1372]*work.v[880]+work.L[1404]*work.v[886];
work.v[498] -= work.L[322]*work.v[499]+work.L[1371]*work.v[880]+work.L[1403]*work.v[886];
work.v[497] -= work.L[319]*work.v[498]+work.L[321]*work.v[499];
work.v[496] -= work.L[317]*work.v[497];
work.v[495] -= work.L[1338]*work.v[874]+work.L[1370]*work.v[880];
work.v[494] -= work.L[315]*work.v[495]+work.L[1337]*work.v[874]+work.L[1369]*work.v[880];
work.v[493] -= work.L[312]*work.v[494]+work.L[314]*work.v[495];
work.v[492] -= work.L[310]*work.v[493];
work.v[491] -= work.L[1304]*work.v[868]+work.L[1336]*work.v[874];
work.v[490] -= work.L[308]*work.v[491]+work.L[1303]*work.v[868]+work.L[1335]*work.v[874];
work.v[489] -= work.L[305]*work.v[490]+work.L[307]*work.v[491];
work.v[488] -= work.L[303]*work.v[489];
work.v[487] -= work.L[1270]*work.v[862]+work.L[1302]*work.v[868];
work.v[486] -= work.L[301]*work.v[487]+work.L[1269]*work.v[862]+work.L[1301]*work.v[868];
work.v[485] -= work.L[298]*work.v[486]+work.L[300]*work.v[487];
work.v[484] -= work.L[296]*work.v[485];
work.v[483] -= work.L[1236]*work.v[856]+work.L[1268]*work.v[862];
work.v[482] -= work.L[294]*work.v[483]+work.L[1235]*work.v[856]+work.L[1267]*work.v[862];
work.v[481] -= work.L[291]*work.v[482]+work.L[293]*work.v[483];
work.v[480] -= work.L[289]*work.v[481];
work.v[479] -= work.L[1202]*work.v[850]+work.L[1234]*work.v[856];
work.v[478] -= work.L[287]*work.v[479]+work.L[1201]*work.v[850]+work.L[1233]*work.v[856];
work.v[477] -= work.L[284]*work.v[478]+work.L[286]*work.v[479];
work.v[476] -= work.L[282]*work.v[477];
work.v[475] -= work.L[1168]*work.v[844]+work.L[1200]*work.v[850];
work.v[474] -= work.L[280]*work.v[475]+work.L[1167]*work.v[844]+work.L[1199]*work.v[850];
work.v[473] -= work.L[277]*work.v[474]+work.L[279]*work.v[475];
work.v[472] -= work.L[275]*work.v[473];
work.v[471] -= work.L[1134]*work.v[838]+work.L[1166]*work.v[844];
work.v[470] -= work.L[273]*work.v[471]+work.L[1133]*work.v[838]+work.L[1165]*work.v[844];
work.v[469] -= work.L[270]*work.v[470]+work.L[272]*work.v[471];
work.v[468] -= work.L[268]*work.v[469];
work.v[467] -= work.L[1100]*work.v[832]+work.L[1132]*work.v[838];
work.v[466] -= work.L[266]*work.v[467]+work.L[1099]*work.v[832]+work.L[1131]*work.v[838];
work.v[465] -= work.L[263]*work.v[466]+work.L[265]*work.v[467];
work.v[464] -= work.L[261]*work.v[465];
work.v[463] -= work.L[1066]*work.v[826]+work.L[1098]*work.v[832];
work.v[462] -= work.L[259]*work.v[463]+work.L[1065]*work.v[826]+work.L[1097]*work.v[832];
work.v[461] -= work.L[256]*work.v[462]+work.L[258]*work.v[463];
work.v[460] -= work.L[254]*work.v[461];
work.v[459] -= work.L[1032]*work.v[820]+work.L[1064]*work.v[826];
work.v[458] -= work.L[252]*work.v[459]+work.L[1031]*work.v[820]+work.L[1063]*work.v[826];
work.v[457] -= work.L[249]*work.v[458]+work.L[251]*work.v[459];
work.v[456] -= work.L[247]*work.v[457];
work.v[455] -= work.L[998]*work.v[814]+work.L[1030]*work.v[820];
work.v[454] -= work.L[245]*work.v[455]+work.L[997]*work.v[814]+work.L[1029]*work.v[820];
work.v[453] -= work.L[242]*work.v[454]+work.L[244]*work.v[455];
work.v[452] -= work.L[240]*work.v[453];
work.v[451] -= work.L[964]*work.v[808]+work.L[996]*work.v[814];
work.v[450] -= work.L[238]*work.v[451]+work.L[963]*work.v[808]+work.L[995]*work.v[814];
work.v[449] -= work.L[235]*work.v[450]+work.L[237]*work.v[451];
work.v[448] -= work.L[233]*work.v[449];
work.v[447] -= work.L[930]*work.v[802]+work.L[962]*work.v[808];
work.v[446] -= work.L[231]*work.v[447]+work.L[929]*work.v[802]+work.L[961]*work.v[808];
work.v[445] -= work.L[228]*work.v[446]+work.L[230]*work.v[447];
work.v[444] -= work.L[226]*work.v[445];
work.v[443] -= work.L[896]*work.v[796]+work.L[928]*work.v[802];
work.v[442] -= work.L[224]*work.v[443]+work.L[895]*work.v[796]+work.L[927]*work.v[802];
work.v[441] -= work.L[221]*work.v[442]+work.L[223]*work.v[443];
work.v[440] -= work.L[219]*work.v[441];
work.v[439] -= work.L[862]*work.v[790]+work.L[894]*work.v[796];
work.v[438] -= work.L[217]*work.v[439]+work.L[861]*work.v[790]+work.L[893]*work.v[796];
work.v[437] -= work.L[214]*work.v[438]+work.L[216]*work.v[439];
work.v[436] -= work.L[212]*work.v[437];
work.v[435] -= work.L[825]*work.v[784]+work.L[860]*work.v[790];
work.v[434] -= work.L[210]*work.v[435]+work.L[824]*work.v[784]+work.L[859]*work.v[790];
work.v[433] -= work.L[207]*work.v[434]+work.L[209]*work.v[435];
work.v[432] -= work.L[205]*work.v[433];
work.v[431] -= work.L[763]*work.v[768]+work.L[823]*work.v[784];
work.v[430] -= work.L[203]*work.v[431]+work.L[762]*work.v[768]+work.L[822]*work.v[784];
work.v[429] -= work.L[200]*work.v[430]+work.L[202]*work.v[431];
work.v[428] -= work.L[198]*work.v[429];
work.v[427] -= work.L[742]*work.v[736]+work.L[761]*work.v[768];
work.v[426] -= work.L[196]*work.v[427]+work.L[741]*work.v[736]+work.L[760]*work.v[768];
work.v[425] -= work.L[193]*work.v[426]+work.L[195]*work.v[427];
work.v[424] -= work.L[191]*work.v[425];
work.v[423] -= work.L[740]*work.v[736];
work.v[422] -= work.L[189]*work.v[423]+work.L[739]*work.v[736];
work.v[421] -= work.L[186]*work.v[422]+work.L[188]*work.v[423];
work.v[420] -= work.L[184]*work.v[421];
work.v[419] -= work.L[734]*work.v[734];
work.v[418] -= work.L[182]*work.v[419]+work.L[733]*work.v[734];
work.v[417] -= work.L[179]*work.v[418]+work.L[181]*work.v[419];
work.v[416] -= work.L[177]*work.v[417];
work.v[415] -= work.L[770]*work.v[772];
work.v[414] -= work.L[175]*work.v[415]+work.L[769]*work.v[772];
work.v[413] -= work.L[172]*work.v[414]+work.L[174]*work.v[415];
work.v[412] -= work.L[170]*work.v[413];
work.v[411] -= work.L[1515]*work.v[904];
work.v[410] -= work.L[168]*work.v[411]+work.L[1514]*work.v[904];
work.v[409] -= work.L[165]*work.v[410]+work.L[167]*work.v[411];
work.v[408] -= work.L[163]*work.v[409];
work.v[407] -= work.L[1490]*work.v[901];
work.v[406] -= work.L[161]*work.v[407]+work.L[1489]*work.v[901];
work.v[405] -= work.L[158]*work.v[406]+work.L[160]*work.v[407];
work.v[404] -= work.L[156]*work.v[405];
work.v[403] -= work.L[1470]*work.v[898];
work.v[402] -= work.L[154]*work.v[403]+work.L[1469]*work.v[898];
work.v[401] -= work.L[151]*work.v[402]+work.L[153]*work.v[403];
work.v[400] -= work.L[149]*work.v[401];
work.v[399] -= work.L[1436]*work.v[892];
work.v[398] -= work.L[147]*work.v[399]+work.L[1435]*work.v[892];
work.v[397] -= work.L[144]*work.v[398]+work.L[146]*work.v[399];
work.v[396] -= work.L[142]*work.v[397];
work.v[395] -= work.L[1402]*work.v[886];
work.v[394] -= work.L[140]*work.v[395]+work.L[1401]*work.v[886];
work.v[393] -= work.L[137]*work.v[394]+work.L[139]*work.v[395];
work.v[392] -= work.L[135]*work.v[393];
work.v[391] -= work.L[1368]*work.v[880];
work.v[390] -= work.L[133]*work.v[391]+work.L[1367]*work.v[880];
work.v[389] -= work.L[130]*work.v[390]+work.L[132]*work.v[391];
work.v[388] -= work.L[128]*work.v[389];
work.v[387] -= work.L[1334]*work.v[874];
work.v[386] -= work.L[126]*work.v[387]+work.L[1333]*work.v[874];
work.v[385] -= work.L[123]*work.v[386]+work.L[125]*work.v[387];
work.v[384] -= work.L[121]*work.v[385];
work.v[383] -= work.L[1300]*work.v[868];
work.v[382] -= work.L[119]*work.v[383]+work.L[1299]*work.v[868];
work.v[381] -= work.L[116]*work.v[382]+work.L[118]*work.v[383];
work.v[380] -= work.L[114]*work.v[381];
work.v[379] -= work.L[1266]*work.v[862];
work.v[378] -= work.L[112]*work.v[379]+work.L[1265]*work.v[862];
work.v[377] -= work.L[109]*work.v[378]+work.L[111]*work.v[379];
work.v[376] -= work.L[107]*work.v[377];
work.v[375] -= work.L[1232]*work.v[856];
work.v[374] -= work.L[105]*work.v[375]+work.L[1231]*work.v[856];
work.v[373] -= work.L[102]*work.v[374]+work.L[104]*work.v[375];
work.v[372] -= work.L[100]*work.v[373];
work.v[371] -= work.L[1198]*work.v[850];
work.v[370] -= work.L[98]*work.v[371]+work.L[1197]*work.v[850];
work.v[369] -= work.L[95]*work.v[370]+work.L[97]*work.v[371];
work.v[368] -= work.L[93]*work.v[369];
work.v[367] -= work.L[1164]*work.v[844];
work.v[366] -= work.L[91]*work.v[367]+work.L[1163]*work.v[844];
work.v[365] -= work.L[88]*work.v[366]+work.L[90]*work.v[367];
work.v[364] -= work.L[86]*work.v[365];
work.v[363] -= work.L[1130]*work.v[838];
work.v[362] -= work.L[84]*work.v[363]+work.L[1129]*work.v[838];
work.v[361] -= work.L[81]*work.v[362]+work.L[83]*work.v[363];
work.v[360] -= work.L[79]*work.v[361];
work.v[359] -= work.L[1096]*work.v[832];
work.v[358] -= work.L[77]*work.v[359]+work.L[1095]*work.v[832];
work.v[357] -= work.L[74]*work.v[358]+work.L[76]*work.v[359];
work.v[356] -= work.L[72]*work.v[357];
work.v[355] -= work.L[1062]*work.v[826];
work.v[354] -= work.L[70]*work.v[355]+work.L[1061]*work.v[826];
work.v[353] -= work.L[67]*work.v[354]+work.L[69]*work.v[355];
work.v[352] -= work.L[65]*work.v[353];
work.v[351] -= work.L[1028]*work.v[820];
work.v[350] -= work.L[63]*work.v[351]+work.L[1027]*work.v[820];
work.v[349] -= work.L[60]*work.v[350]+work.L[62]*work.v[351];
work.v[348] -= work.L[58]*work.v[349];
work.v[347] -= work.L[994]*work.v[814];
work.v[346] -= work.L[56]*work.v[347]+work.L[993]*work.v[814];
work.v[345] -= work.L[53]*work.v[346]+work.L[55]*work.v[347];
work.v[344] -= work.L[51]*work.v[345];
work.v[343] -= work.L[960]*work.v[808];
work.v[342] -= work.L[49]*work.v[343]+work.L[959]*work.v[808];
work.v[341] -= work.L[46]*work.v[342]+work.L[48]*work.v[343];
work.v[340] -= work.L[44]*work.v[341];
work.v[339] -= work.L[926]*work.v[802];
work.v[338] -= work.L[42]*work.v[339]+work.L[925]*work.v[802];
work.v[337] -= work.L[39]*work.v[338]+work.L[41]*work.v[339];
work.v[336] -= work.L[37]*work.v[337];
work.v[335] -= work.L[892]*work.v[796];
work.v[334] -= work.L[35]*work.v[335]+work.L[891]*work.v[796];
work.v[333] -= work.L[32]*work.v[334]+work.L[34]*work.v[335];
work.v[332] -= work.L[30]*work.v[333];
work.v[331] -= work.L[858]*work.v[790];
work.v[330] -= work.L[28]*work.v[331]+work.L[857]*work.v[790];
work.v[329] -= work.L[25]*work.v[330]+work.L[27]*work.v[331];
work.v[328] -= work.L[23]*work.v[329];
work.v[327] -= work.L[821]*work.v[784];
work.v[326] -= work.L[21]*work.v[327]+work.L[820]*work.v[784];
work.v[325] -= work.L[18]*work.v[326]+work.L[20]*work.v[327];
work.v[324] -= work.L[16]*work.v[325];
work.v[323] -= work.L[759]*work.v[768];
work.v[322] -= work.L[14]*work.v[323]+work.L[758]*work.v[768];
work.v[321] -= work.L[11]*work.v[322]+work.L[13]*work.v[323];
work.v[320] -= work.L[9]*work.v[321];
work.v[319] -= work.L[738]*work.v[736];
work.v[318] -= work.L[7]*work.v[319]+work.L[737]*work.v[736];
work.v[317] -= work.L[4]*work.v[318]+work.L[6]*work.v[319];
work.v[316] -= work.L[2]*work.v[317];
work.v[315] -= work.L[745]*work.v[738];
work.v[314] -= work.L[744]*work.v[737];
work.v[313] -= work.L[749]*work.v[741];
work.v[312] -= work.L[0]*work.v[314];
work.v[311] -= work.L[728]*work.v[732];
work.v[310] -= work.L[726]*work.v[731];
work.v[309] -= work.L[724]*work.v[729];
work.v[308] -= work.L[721]*work.v[728];
work.v[307] -= work.L[719]*work.v[727];
work.v[306] -= work.L[717]*work.v[725];
work.v[305] -= work.L[714]*work.v[724];
work.v[304] -= work.L[712]*work.v[723];
work.v[303] -= work.L[710]*work.v[721];
work.v[302] -= work.L[707]*work.v[720];
work.v[301] -= work.L[705]*work.v[719];
work.v[300] -= work.L[703]*work.v[717];
work.v[299] -= work.L[700]*work.v[716];
work.v[298] -= work.L[698]*work.v[715];
work.v[297] -= work.L[696]*work.v[713];
work.v[296] -= work.L[693]*work.v[712];
work.v[295] -= work.L[691]*work.v[711];
work.v[294] -= work.L[689]*work.v[709];
work.v[293] -= work.L[686]*work.v[708];
work.v[292] -= work.L[684]*work.v[707];
work.v[291] -= work.L[682]*work.v[705];
work.v[290] -= work.L[679]*work.v[704];
work.v[289] -= work.L[677]*work.v[703];
work.v[288] -= work.L[675]*work.v[701];
work.v[287] -= work.L[672]*work.v[700];
work.v[286] -= work.L[670]*work.v[699];
work.v[285] -= work.L[668]*work.v[697];
work.v[284] -= work.L[665]*work.v[696];
work.v[283] -= work.L[663]*work.v[695];
work.v[282] -= work.L[661]*work.v[693];
work.v[281] -= work.L[658]*work.v[692];
work.v[280] -= work.L[656]*work.v[691];
work.v[279] -= work.L[654]*work.v[689];
work.v[278] -= work.L[651]*work.v[688];
work.v[277] -= work.L[649]*work.v[687];
work.v[276] -= work.L[647]*work.v[685];
work.v[275] -= work.L[644]*work.v[684];
work.v[274] -= work.L[642]*work.v[683];
work.v[273] -= work.L[640]*work.v[681];
work.v[272] -= work.L[637]*work.v[680];
work.v[271] -= work.L[635]*work.v[679];
work.v[270] -= work.L[633]*work.v[677];
work.v[269] -= work.L[630]*work.v[676];
work.v[268] -= work.L[628]*work.v[675];
work.v[267] -= work.L[626]*work.v[673];
work.v[266] -= work.L[623]*work.v[672];
work.v[265] -= work.L[621]*work.v[671];
work.v[264] -= work.L[619]*work.v[669];
work.v[263] -= work.L[616]*work.v[668];
work.v[262] -= work.L[614]*work.v[667];
work.v[261] -= work.L[612]*work.v[665];
work.v[260] -= work.L[609]*work.v[664];
work.v[259] -= work.L[607]*work.v[663];
work.v[258] -= work.L[605]*work.v[661];
work.v[257] -= work.L[602]*work.v[660];
work.v[256] -= work.L[600]*work.v[659];
work.v[255] -= work.L[598]*work.v[657];
work.v[254] -= work.L[595]*work.v[656];
work.v[253] -= work.L[593]*work.v[655];
work.v[252] -= work.L[591]*work.v[653];
work.v[251] -= work.L[588]*work.v[652];
work.v[250] -= work.L[586]*work.v[651];
work.v[249] -= work.L[584]*work.v[649];
work.v[248] -= work.L[581]*work.v[648];
work.v[247] -= work.L[579]*work.v[647];
work.v[246] -= work.L[577]*work.v[645];
work.v[245] -= work.L[574]*work.v[644];
work.v[244] -= work.L[572]*work.v[643];
work.v[243] -= work.L[570]*work.v[641];
work.v[242] -= work.L[567]*work.v[640];
work.v[241] -= work.L[565]*work.v[639];
work.v[240] -= work.L[563]*work.v[637];
work.v[239] -= work.L[560]*work.v[636];
work.v[238] -= work.L[558]*work.v[635];
work.v[237] -= work.L[556]*work.v[633];
work.v[236] -= work.L[553]*work.v[632];
work.v[235] -= work.L[551]*work.v[631];
work.v[234] -= work.L[549]*work.v[629];
work.v[233] -= work.L[544]*work.v[627];
work.v[232] -= work.L[542]*work.v[626];
work.v[231] -= work.L[540]*work.v[624];
work.v[230] -= work.L[537]*work.v[623];
work.v[229] -= work.L[535]*work.v[622];
work.v[228] -= work.L[533]*work.v[620];
work.v[227] -= work.L[530]*work.v[619];
work.v[226] -= work.L[528]*work.v[618];
work.v[225] -= work.L[526]*work.v[616];
work.v[224] -= work.L[523]*work.v[615];
work.v[223] -= work.L[521]*work.v[614];
work.v[222] -= work.L[519]*work.v[612];
work.v[221] -= work.L[516]*work.v[611];
work.v[220] -= work.L[514]*work.v[610];
work.v[219] -= work.L[512]*work.v[608];
work.v[218] -= work.L[509]*work.v[607];
work.v[217] -= work.L[507]*work.v[606];
work.v[216] -= work.L[505]*work.v[604];
work.v[215] -= work.L[502]*work.v[603];
work.v[214] -= work.L[500]*work.v[602];
work.v[213] -= work.L[498]*work.v[600];
work.v[212] -= work.L[495]*work.v[599];
work.v[211] -= work.L[493]*work.v[598];
work.v[210] -= work.L[491]*work.v[596];
work.v[209] -= work.L[488]*work.v[595];
work.v[208] -= work.L[486]*work.v[594];
work.v[207] -= work.L[484]*work.v[592];
work.v[206] -= work.L[481]*work.v[591];
work.v[205] -= work.L[479]*work.v[590];
work.v[204] -= work.L[477]*work.v[588];
work.v[203] -= work.L[474]*work.v[587];
work.v[202] -= work.L[472]*work.v[586];
work.v[201] -= work.L[470]*work.v[584];
work.v[200] -= work.L[467]*work.v[583];
work.v[199] -= work.L[465]*work.v[582];
work.v[198] -= work.L[463]*work.v[580];
work.v[197] -= work.L[460]*work.v[579];
work.v[196] -= work.L[458]*work.v[578];
work.v[195] -= work.L[456]*work.v[576];
work.v[194] -= work.L[453]*work.v[575];
work.v[193] -= work.L[451]*work.v[574];
work.v[192] -= work.L[449]*work.v[572];
work.v[191] -= work.L[446]*work.v[571];
work.v[190] -= work.L[444]*work.v[570];
work.v[189] -= work.L[442]*work.v[568];
work.v[188] -= work.L[439]*work.v[567];
work.v[187] -= work.L[437]*work.v[566];
work.v[186] -= work.L[435]*work.v[564];
work.v[185] -= work.L[432]*work.v[563];
work.v[184] -= work.L[430]*work.v[562];
work.v[183] -= work.L[428]*work.v[560];
work.v[182] -= work.L[425]*work.v[559];
work.v[181] -= work.L[423]*work.v[558];
work.v[180] -= work.L[421]*work.v[556];
work.v[179] -= work.L[418]*work.v[555];
work.v[178] -= work.L[416]*work.v[554];
work.v[177] -= work.L[414]*work.v[552];
work.v[176] -= work.L[411]*work.v[551];
work.v[175] -= work.L[409]*work.v[550];
work.v[174] -= work.L[407]*work.v[548];
work.v[173] -= work.L[404]*work.v[547];
work.v[172] -= work.L[402]*work.v[546];
work.v[171] -= work.L[400]*work.v[544];
work.v[170] -= work.L[397]*work.v[543];
work.v[169] -= work.L[395]*work.v[542];
work.v[168] -= work.L[393]*work.v[540];
work.v[167] -= work.L[390]*work.v[539];
work.v[166] -= work.L[388]*work.v[538];
work.v[165] -= work.L[386]*work.v[536];
work.v[164] -= work.L[383]*work.v[535];
work.v[163] -= work.L[381]*work.v[534];
work.v[162] -= work.L[379]*work.v[532];
work.v[161] -= work.L[376]*work.v[531];
work.v[160] -= work.L[374]*work.v[530];
work.v[159] -= work.L[372]*work.v[528];
work.v[158] -= work.L[369]*work.v[527];
work.v[157] -= work.L[367]*work.v[526];
work.v[156] -= work.L[365]*work.v[524];
work.v[155] -= work.L[362]*work.v[523];
work.v[154] -= work.L[360]*work.v[522];
work.v[153] -= work.L[358]*work.v[520];
work.v[152] -= work.L[355]*work.v[519];
work.v[151] -= work.L[353]*work.v[518];
work.v[150] -= work.L[351]*work.v[516];
work.v[149] -= work.L[348]*work.v[515];
work.v[148] -= work.L[346]*work.v[514];
work.v[147] -= work.L[344]*work.v[512];
work.v[146] -= work.L[341]*work.v[511];
work.v[145] -= work.L[339]*work.v[510];
work.v[144] -= work.L[337]*work.v[508];
work.v[143] -= work.L[334]*work.v[507];
work.v[142] -= work.L[332]*work.v[506];
work.v[141] -= work.L[330]*work.v[504];
work.v[140] -= work.L[327]*work.v[503];
work.v[139] -= work.L[325]*work.v[502];
work.v[138] -= work.L[323]*work.v[500];
work.v[137] -= work.L[320]*work.v[499];
work.v[136] -= work.L[318]*work.v[498];
work.v[135] -= work.L[316]*work.v[496];
work.v[134] -= work.L[313]*work.v[495];
work.v[133] -= work.L[311]*work.v[494];
work.v[132] -= work.L[309]*work.v[492];
work.v[131] -= work.L[306]*work.v[491];
work.v[130] -= work.L[304]*work.v[490];
work.v[129] -= work.L[302]*work.v[488];
work.v[128] -= work.L[299]*work.v[487];
work.v[127] -= work.L[297]*work.v[486];
work.v[126] -= work.L[295]*work.v[484];
work.v[125] -= work.L[292]*work.v[483];
work.v[124] -= work.L[290]*work.v[482];
work.v[123] -= work.L[288]*work.v[480];
work.v[122] -= work.L[285]*work.v[479];
work.v[121] -= work.L[283]*work.v[478];
work.v[120] -= work.L[281]*work.v[476];
work.v[119] -= work.L[278]*work.v[475];
work.v[118] -= work.L[276]*work.v[474];
work.v[117] -= work.L[274]*work.v[472];
work.v[116] -= work.L[271]*work.v[471];
work.v[115] -= work.L[269]*work.v[470];
work.v[114] -= work.L[267]*work.v[468];
work.v[113] -= work.L[264]*work.v[467];
work.v[112] -= work.L[262]*work.v[466];
work.v[111] -= work.L[260]*work.v[464];
work.v[110] -= work.L[257]*work.v[463];
work.v[109] -= work.L[255]*work.v[462];
work.v[108] -= work.L[253]*work.v[460];
work.v[107] -= work.L[250]*work.v[459];
work.v[106] -= work.L[248]*work.v[458];
work.v[105] -= work.L[246]*work.v[456];
work.v[104] -= work.L[243]*work.v[455];
work.v[103] -= work.L[241]*work.v[454];
work.v[102] -= work.L[239]*work.v[452];
work.v[101] -= work.L[236]*work.v[451];
work.v[100] -= work.L[234]*work.v[450];
work.v[99] -= work.L[232]*work.v[448];
work.v[98] -= work.L[229]*work.v[447];
work.v[97] -= work.L[227]*work.v[446];
work.v[96] -= work.L[225]*work.v[444];
work.v[95] -= work.L[222]*work.v[443];
work.v[94] -= work.L[220]*work.v[442];
work.v[93] -= work.L[218]*work.v[440];
work.v[92] -= work.L[215]*work.v[439];
work.v[91] -= work.L[213]*work.v[438];
work.v[90] -= work.L[211]*work.v[436];
work.v[89] -= work.L[208]*work.v[435];
work.v[88] -= work.L[206]*work.v[434];
work.v[87] -= work.L[204]*work.v[432];
work.v[86] -= work.L[201]*work.v[431];
work.v[85] -= work.L[199]*work.v[430];
work.v[84] -= work.L[197]*work.v[428];
work.v[83] -= work.L[194]*work.v[427];
work.v[82] -= work.L[192]*work.v[426];
work.v[81] -= work.L[190]*work.v[424];
work.v[80] -= work.L[187]*work.v[423];
work.v[79] -= work.L[185]*work.v[422];
work.v[78] -= work.L[183]*work.v[420];
work.v[77] -= work.L[180]*work.v[419];
work.v[76] -= work.L[178]*work.v[418];
work.v[75] -= work.L[176]*work.v[416];
work.v[74] -= work.L[173]*work.v[415];
work.v[73] -= work.L[171]*work.v[414];
work.v[72] -= work.L[169]*work.v[412];
work.v[71] -= work.L[166]*work.v[411];
work.v[70] -= work.L[164]*work.v[410];
work.v[69] -= work.L[162]*work.v[408];
work.v[68] -= work.L[159]*work.v[407];
work.v[67] -= work.L[157]*work.v[406];
work.v[66] -= work.L[155]*work.v[404];
work.v[65] -= work.L[152]*work.v[403];
work.v[64] -= work.L[150]*work.v[402];
work.v[63] -= work.L[148]*work.v[400];
work.v[62] -= work.L[145]*work.v[399];
work.v[61] -= work.L[143]*work.v[398];
work.v[60] -= work.L[141]*work.v[396];
work.v[59] -= work.L[138]*work.v[395];
work.v[58] -= work.L[136]*work.v[394];
work.v[57] -= work.L[134]*work.v[392];
work.v[56] -= work.L[131]*work.v[391];
work.v[55] -= work.L[129]*work.v[390];
work.v[54] -= work.L[127]*work.v[388];
work.v[53] -= work.L[124]*work.v[387];
work.v[52] -= work.L[122]*work.v[386];
work.v[51] -= work.L[120]*work.v[384];
work.v[50] -= work.L[117]*work.v[383];
work.v[49] -= work.L[115]*work.v[382];
work.v[48] -= work.L[113]*work.v[380];
work.v[47] -= work.L[110]*work.v[379];
work.v[46] -= work.L[108]*work.v[378];
work.v[45] -= work.L[106]*work.v[376];
work.v[44] -= work.L[103]*work.v[375];
work.v[43] -= work.L[101]*work.v[374];
work.v[42] -= work.L[99]*work.v[372];
work.v[41] -= work.L[96]*work.v[371];
work.v[40] -= work.L[94]*work.v[370];
work.v[39] -= work.L[92]*work.v[368];
work.v[38] -= work.L[89]*work.v[367];
work.v[37] -= work.L[87]*work.v[366];
work.v[36] -= work.L[85]*work.v[364];
work.v[35] -= work.L[82]*work.v[363];
work.v[34] -= work.L[80]*work.v[362];
work.v[33] -= work.L[78]*work.v[360];
work.v[32] -= work.L[75]*work.v[359];
work.v[31] -= work.L[73]*work.v[358];
work.v[30] -= work.L[71]*work.v[356];
work.v[29] -= work.L[68]*work.v[355];
work.v[28] -= work.L[66]*work.v[354];
work.v[27] -= work.L[64]*work.v[352];
work.v[26] -= work.L[61]*work.v[351];
work.v[25] -= work.L[59]*work.v[350];
work.v[24] -= work.L[57]*work.v[348];
work.v[23] -= work.L[54]*work.v[347];
work.v[22] -= work.L[52]*work.v[346];
work.v[21] -= work.L[50]*work.v[344];
work.v[20] -= work.L[47]*work.v[343];
work.v[19] -= work.L[45]*work.v[342];
work.v[18] -= work.L[43]*work.v[340];
work.v[17] -= work.L[40]*work.v[339];
work.v[16] -= work.L[38]*work.v[338];
work.v[15] -= work.L[36]*work.v[336];
work.v[14] -= work.L[33]*work.v[335];
work.v[13] -= work.L[31]*work.v[334];
work.v[12] -= work.L[29]*work.v[332];
work.v[11] -= work.L[26]*work.v[331];
work.v[10] -= work.L[24]*work.v[330];
work.v[9] -= work.L[22]*work.v[328];
work.v[8] -= work.L[19]*work.v[327];
work.v[7] -= work.L[17]*work.v[326];
work.v[6] -= work.L[15]*work.v[324];
work.v[5] -= work.L[12]*work.v[323];
work.v[4] -= work.L[10]*work.v[322];
work.v[3] -= work.L[8]*work.v[320];
work.v[2] -= work.L[5]*work.v[319];
work.v[1] -= work.L[3]*work.v[318];
work.v[0] -= work.L[1]*work.v[316];
/* Unpermute the result, from v to var. */
var[0] = work.v[317];
var[1] = work.v[321];
var[2] = work.v[325];
var[3] = work.v[329];
var[4] = work.v[333];
var[5] = work.v[337];
var[6] = work.v[341];
var[7] = work.v[345];
var[8] = work.v[349];
var[9] = work.v[353];
var[10] = work.v[357];
var[11] = work.v[361];
var[12] = work.v[365];
var[13] = work.v[369];
var[14] = work.v[373];
var[15] = work.v[377];
var[16] = work.v[381];
var[17] = work.v[385];
var[18] = work.v[389];
var[19] = work.v[393];
var[20] = work.v[397];
var[21] = work.v[401];
var[22] = work.v[405];
var[23] = work.v[409];
var[24] = work.v[413];
var[25] = work.v[417];
var[26] = work.v[421];
var[27] = work.v[425];
var[28] = work.v[429];
var[29] = work.v[433];
var[30] = work.v[437];
var[31] = work.v[441];
var[32] = work.v[445];
var[33] = work.v[449];
var[34] = work.v[453];
var[35] = work.v[457];
var[36] = work.v[461];
var[37] = work.v[465];
var[38] = work.v[469];
var[39] = work.v[473];
var[40] = work.v[477];
var[41] = work.v[481];
var[42] = work.v[485];
var[43] = work.v[489];
var[44] = work.v[493];
var[45] = work.v[497];
var[46] = work.v[501];
var[47] = work.v[505];
var[48] = work.v[509];
var[49] = work.v[513];
var[50] = work.v[517];
var[51] = work.v[521];
var[52] = work.v[525];
var[53] = work.v[529];
var[54] = work.v[533];
var[55] = work.v[537];
var[56] = work.v[541];
var[57] = work.v[545];
var[58] = work.v[549];
var[59] = work.v[553];
var[60] = work.v[557];
var[61] = work.v[561];
var[62] = work.v[565];
var[63] = work.v[569];
var[64] = work.v[573];
var[65] = work.v[577];
var[66] = work.v[581];
var[67] = work.v[585];
var[68] = work.v[589];
var[69] = work.v[593];
var[70] = work.v[597];
var[71] = work.v[601];
var[72] = work.v[605];
var[73] = work.v[609];
var[74] = work.v[613];
var[75] = work.v[617];
var[76] = work.v[621];
var[77] = work.v[625];
var[78] = work.v[630];
var[79] = work.v[634];
var[80] = work.v[638];
var[81] = work.v[642];
var[82] = work.v[646];
var[83] = work.v[650];
var[84] = work.v[654];
var[85] = work.v[658];
var[86] = work.v[662];
var[87] = work.v[666];
var[88] = work.v[670];
var[89] = work.v[674];
var[90] = work.v[678];
var[91] = work.v[682];
var[92] = work.v[686];
var[93] = work.v[690];
var[94] = work.v[694];
var[95] = work.v[698];
var[96] = work.v[702];
var[97] = work.v[706];
var[98] = work.v[710];
var[99] = work.v[714];
var[100] = work.v[718];
var[101] = work.v[722];
var[102] = work.v[726];
var[103] = work.v[730];
var[104] = work.v[736];
var[105] = work.v[768];
var[106] = work.v[784];
var[107] = work.v[790];
var[108] = work.v[796];
var[109] = work.v[802];
var[110] = work.v[808];
var[111] = work.v[814];
var[112] = work.v[820];
var[113] = work.v[826];
var[114] = work.v[832];
var[115] = work.v[838];
var[116] = work.v[844];
var[117] = work.v[850];
var[118] = work.v[856];
var[119] = work.v[862];
var[120] = work.v[868];
var[121] = work.v[874];
var[122] = work.v[880];
var[123] = work.v[886];
var[124] = work.v[892];
var[125] = work.v[898];
var[126] = work.v[901];
var[127] = work.v[904];
var[128] = work.v[772];
var[129] = work.v[734];
var[130] = work.v[314];
var[131] = work.v[741];
var[132] = work.v[778];
var[133] = work.v[742];
var[134] = work.v[777];
var[135] = work.v[779];
var[136] = work.v[743];
var[137] = work.v[782];
var[138] = work.v[786];
var[139] = work.v[744];
var[140] = work.v[788];
var[141] = work.v[792];
var[142] = work.v[745];
var[143] = work.v[794];
var[144] = work.v[798];
var[145] = work.v[746];
var[146] = work.v[800];
var[147] = work.v[804];
var[148] = work.v[747];
var[149] = work.v[806];
var[150] = work.v[810];
var[151] = work.v[748];
var[152] = work.v[812];
var[153] = work.v[816];
var[154] = work.v[749];
var[155] = work.v[818];
var[156] = work.v[822];
var[157] = work.v[750];
var[158] = work.v[824];
var[159] = work.v[828];
var[160] = work.v[751];
var[161] = work.v[830];
var[162] = work.v[834];
var[163] = work.v[752];
var[164] = work.v[836];
var[165] = work.v[840];
var[166] = work.v[753];
var[167] = work.v[842];
var[168] = work.v[846];
var[169] = work.v[754];
var[170] = work.v[848];
var[171] = work.v[852];
var[172] = work.v[755];
var[173] = work.v[854];
var[174] = work.v[858];
var[175] = work.v[756];
var[176] = work.v[860];
var[177] = work.v[864];
var[178] = work.v[757];
var[179] = work.v[866];
var[180] = work.v[870];
var[181] = work.v[758];
var[182] = work.v[872];
var[183] = work.v[876];
var[184] = work.v[759];
var[185] = work.v[878];
var[186] = work.v[882];
var[187] = work.v[760];
var[188] = work.v[884];
var[189] = work.v[888];
var[190] = work.v[761];
var[191] = work.v[890];
var[192] = work.v[894];
var[193] = work.v[762];
var[194] = work.v[896];
var[195] = work.v[900];
var[196] = work.v[763];
var[197] = work.v[907];
var[198] = work.v[908];
var[199] = work.v[764];
var[200] = work.v[909];
var[201] = work.v[903];
var[202] = work.v[765];
var[203] = work.v[902];
var[204] = work.v[773];
var[205] = work.v[315];
var[206] = work.v[628];
var[207] = work.v[733];
var[208] = work.v[0];
var[209] = work.v[1];
var[210] = work.v[2];
var[211] = work.v[3];
var[212] = work.v[4];
var[213] = work.v[5];
var[214] = work.v[6];
var[215] = work.v[7];
var[216] = work.v[8];
var[217] = work.v[9];
var[218] = work.v[10];
var[219] = work.v[11];
var[220] = work.v[12];
var[221] = work.v[13];
var[222] = work.v[14];
var[223] = work.v[15];
var[224] = work.v[16];
var[225] = work.v[17];
var[226] = work.v[18];
var[227] = work.v[19];
var[228] = work.v[20];
var[229] = work.v[21];
var[230] = work.v[22];
var[231] = work.v[23];
var[232] = work.v[24];
var[233] = work.v[25];
var[234] = work.v[26];
var[235] = work.v[27];
var[236] = work.v[28];
var[237] = work.v[29];
var[238] = work.v[30];
var[239] = work.v[31];
var[240] = work.v[32];
var[241] = work.v[33];
var[242] = work.v[34];
var[243] = work.v[35];
var[244] = work.v[36];
var[245] = work.v[37];
var[246] = work.v[38];
var[247] = work.v[39];
var[248] = work.v[40];
var[249] = work.v[41];
var[250] = work.v[42];
var[251] = work.v[43];
var[252] = work.v[44];
var[253] = work.v[45];
var[254] = work.v[46];
var[255] = work.v[47];
var[256] = work.v[48];
var[257] = work.v[49];
var[258] = work.v[50];
var[259] = work.v[51];
var[260] = work.v[52];
var[261] = work.v[53];
var[262] = work.v[54];
var[263] = work.v[55];
var[264] = work.v[56];
var[265] = work.v[57];
var[266] = work.v[58];
var[267] = work.v[59];
var[268] = work.v[60];
var[269] = work.v[61];
var[270] = work.v[62];
var[271] = work.v[63];
var[272] = work.v[64];
var[273] = work.v[65];
var[274] = work.v[66];
var[275] = work.v[67];
var[276] = work.v[68];
var[277] = work.v[69];
var[278] = work.v[70];
var[279] = work.v[71];
var[280] = work.v[72];
var[281] = work.v[73];
var[282] = work.v[74];
var[283] = work.v[75];
var[284] = work.v[76];
var[285] = work.v[77];
var[286] = work.v[78];
var[287] = work.v[79];
var[288] = work.v[80];
var[289] = work.v[81];
var[290] = work.v[82];
var[291] = work.v[83];
var[292] = work.v[84];
var[293] = work.v[85];
var[294] = work.v[86];
var[295] = work.v[87];
var[296] = work.v[88];
var[297] = work.v[89];
var[298] = work.v[90];
var[299] = work.v[91];
var[300] = work.v[92];
var[301] = work.v[93];
var[302] = work.v[94];
var[303] = work.v[95];
var[304] = work.v[96];
var[305] = work.v[97];
var[306] = work.v[98];
var[307] = work.v[99];
var[308] = work.v[100];
var[309] = work.v[101];
var[310] = work.v[102];
var[311] = work.v[103];
var[312] = work.v[104];
var[313] = work.v[105];
var[314] = work.v[106];
var[315] = work.v[107];
var[316] = work.v[108];
var[317] = work.v[109];
var[318] = work.v[110];
var[319] = work.v[111];
var[320] = work.v[112];
var[321] = work.v[113];
var[322] = work.v[114];
var[323] = work.v[115];
var[324] = work.v[116];
var[325] = work.v[117];
var[326] = work.v[118];
var[327] = work.v[119];
var[328] = work.v[120];
var[329] = work.v[121];
var[330] = work.v[122];
var[331] = work.v[123];
var[332] = work.v[124];
var[333] = work.v[125];
var[334] = work.v[126];
var[335] = work.v[127];
var[336] = work.v[128];
var[337] = work.v[129];
var[338] = work.v[130];
var[339] = work.v[131];
var[340] = work.v[132];
var[341] = work.v[133];
var[342] = work.v[134];
var[343] = work.v[135];
var[344] = work.v[136];
var[345] = work.v[137];
var[346] = work.v[138];
var[347] = work.v[139];
var[348] = work.v[140];
var[349] = work.v[141];
var[350] = work.v[142];
var[351] = work.v[143];
var[352] = work.v[144];
var[353] = work.v[145];
var[354] = work.v[146];
var[355] = work.v[147];
var[356] = work.v[148];
var[357] = work.v[149];
var[358] = work.v[150];
var[359] = work.v[151];
var[360] = work.v[152];
var[361] = work.v[153];
var[362] = work.v[154];
var[363] = work.v[155];
var[364] = work.v[156];
var[365] = work.v[157];
var[366] = work.v[158];
var[367] = work.v[159];
var[368] = work.v[160];
var[369] = work.v[161];
var[370] = work.v[162];
var[371] = work.v[163];
var[372] = work.v[164];
var[373] = work.v[165];
var[374] = work.v[166];
var[375] = work.v[167];
var[376] = work.v[168];
var[377] = work.v[169];
var[378] = work.v[170];
var[379] = work.v[171];
var[380] = work.v[172];
var[381] = work.v[173];
var[382] = work.v[174];
var[383] = work.v[175];
var[384] = work.v[176];
var[385] = work.v[177];
var[386] = work.v[178];
var[387] = work.v[179];
var[388] = work.v[180];
var[389] = work.v[181];
var[390] = work.v[182];
var[391] = work.v[183];
var[392] = work.v[184];
var[393] = work.v[185];
var[394] = work.v[186];
var[395] = work.v[187];
var[396] = work.v[188];
var[397] = work.v[189];
var[398] = work.v[190];
var[399] = work.v[191];
var[400] = work.v[192];
var[401] = work.v[193];
var[402] = work.v[194];
var[403] = work.v[195];
var[404] = work.v[196];
var[405] = work.v[197];
var[406] = work.v[198];
var[407] = work.v[199];
var[408] = work.v[200];
var[409] = work.v[201];
var[410] = work.v[202];
var[411] = work.v[203];
var[412] = work.v[204];
var[413] = work.v[205];
var[414] = work.v[206];
var[415] = work.v[207];
var[416] = work.v[208];
var[417] = work.v[209];
var[418] = work.v[210];
var[419] = work.v[211];
var[420] = work.v[212];
var[421] = work.v[213];
var[422] = work.v[214];
var[423] = work.v[215];
var[424] = work.v[216];
var[425] = work.v[217];
var[426] = work.v[218];
var[427] = work.v[219];
var[428] = work.v[220];
var[429] = work.v[221];
var[430] = work.v[222];
var[431] = work.v[223];
var[432] = work.v[224];
var[433] = work.v[225];
var[434] = work.v[226];
var[435] = work.v[227];
var[436] = work.v[228];
var[437] = work.v[229];
var[438] = work.v[230];
var[439] = work.v[231];
var[440] = work.v[232];
var[441] = work.v[233];
var[442] = work.v[234];
var[443] = work.v[235];
var[444] = work.v[236];
var[445] = work.v[237];
var[446] = work.v[238];
var[447] = work.v[239];
var[448] = work.v[240];
var[449] = work.v[241];
var[450] = work.v[242];
var[451] = work.v[243];
var[452] = work.v[244];
var[453] = work.v[245];
var[454] = work.v[246];
var[455] = work.v[247];
var[456] = work.v[248];
var[457] = work.v[249];
var[458] = work.v[250];
var[459] = work.v[251];
var[460] = work.v[252];
var[461] = work.v[253];
var[462] = work.v[254];
var[463] = work.v[255];
var[464] = work.v[256];
var[465] = work.v[257];
var[466] = work.v[258];
var[467] = work.v[259];
var[468] = work.v[260];
var[469] = work.v[261];
var[470] = work.v[262];
var[471] = work.v[263];
var[472] = work.v[264];
var[473] = work.v[265];
var[474] = work.v[266];
var[475] = work.v[267];
var[476] = work.v[268];
var[477] = work.v[269];
var[478] = work.v[270];
var[479] = work.v[271];
var[480] = work.v[272];
var[481] = work.v[273];
var[482] = work.v[274];
var[483] = work.v[275];
var[484] = work.v[276];
var[485] = work.v[277];
var[486] = work.v[278];
var[487] = work.v[279];
var[488] = work.v[280];
var[489] = work.v[281];
var[490] = work.v[282];
var[491] = work.v[283];
var[492] = work.v[284];
var[493] = work.v[285];
var[494] = work.v[286];
var[495] = work.v[287];
var[496] = work.v[288];
var[497] = work.v[289];
var[498] = work.v[290];
var[499] = work.v[291];
var[500] = work.v[292];
var[501] = work.v[293];
var[502] = work.v[294];
var[503] = work.v[295];
var[504] = work.v[296];
var[505] = work.v[297];
var[506] = work.v[298];
var[507] = work.v[299];
var[508] = work.v[300];
var[509] = work.v[301];
var[510] = work.v[302];
var[511] = work.v[303];
var[512] = work.v[304];
var[513] = work.v[305];
var[514] = work.v[306];
var[515] = work.v[307];
var[516] = work.v[308];
var[517] = work.v[309];
var[518] = work.v[310];
var[519] = work.v[311];
var[520] = work.v[316];
var[521] = work.v[318];
var[522] = work.v[319];
var[523] = work.v[320];
var[524] = work.v[322];
var[525] = work.v[323];
var[526] = work.v[324];
var[527] = work.v[326];
var[528] = work.v[327];
var[529] = work.v[328];
var[530] = work.v[330];
var[531] = work.v[331];
var[532] = work.v[332];
var[533] = work.v[334];
var[534] = work.v[335];
var[535] = work.v[336];
var[536] = work.v[338];
var[537] = work.v[339];
var[538] = work.v[340];
var[539] = work.v[342];
var[540] = work.v[343];
var[541] = work.v[344];
var[542] = work.v[346];
var[543] = work.v[347];
var[544] = work.v[348];
var[545] = work.v[350];
var[546] = work.v[351];
var[547] = work.v[352];
var[548] = work.v[354];
var[549] = work.v[355];
var[550] = work.v[356];
var[551] = work.v[358];
var[552] = work.v[359];
var[553] = work.v[360];
var[554] = work.v[362];
var[555] = work.v[363];
var[556] = work.v[364];
var[557] = work.v[366];
var[558] = work.v[367];
var[559] = work.v[368];
var[560] = work.v[370];
var[561] = work.v[371];
var[562] = work.v[372];
var[563] = work.v[374];
var[564] = work.v[375];
var[565] = work.v[376];
var[566] = work.v[378];
var[567] = work.v[379];
var[568] = work.v[380];
var[569] = work.v[382];
var[570] = work.v[383];
var[571] = work.v[384];
var[572] = work.v[386];
var[573] = work.v[387];
var[574] = work.v[388];
var[575] = work.v[390];
var[576] = work.v[391];
var[577] = work.v[392];
var[578] = work.v[394];
var[579] = work.v[395];
var[580] = work.v[396];
var[581] = work.v[398];
var[582] = work.v[399];
var[583] = work.v[400];
var[584] = work.v[402];
var[585] = work.v[403];
var[586] = work.v[404];
var[587] = work.v[406];
var[588] = work.v[407];
var[589] = work.v[408];
var[590] = work.v[410];
var[591] = work.v[411];
var[592] = work.v[412];
var[593] = work.v[414];
var[594] = work.v[415];
var[595] = work.v[416];
var[596] = work.v[418];
var[597] = work.v[419];
var[598] = work.v[420];
var[599] = work.v[422];
var[600] = work.v[423];
var[601] = work.v[424];
var[602] = work.v[426];
var[603] = work.v[427];
var[604] = work.v[428];
var[605] = work.v[430];
var[606] = work.v[431];
var[607] = work.v[432];
var[608] = work.v[434];
var[609] = work.v[435];
var[610] = work.v[436];
var[611] = work.v[438];
var[612] = work.v[439];
var[613] = work.v[440];
var[614] = work.v[442];
var[615] = work.v[443];
var[616] = work.v[444];
var[617] = work.v[446];
var[618] = work.v[447];
var[619] = work.v[448];
var[620] = work.v[450];
var[621] = work.v[451];
var[622] = work.v[452];
var[623] = work.v[454];
var[624] = work.v[455];
var[625] = work.v[456];
var[626] = work.v[458];
var[627] = work.v[459];
var[628] = work.v[460];
var[629] = work.v[462];
var[630] = work.v[463];
var[631] = work.v[464];
var[632] = work.v[466];
var[633] = work.v[467];
var[634] = work.v[468];
var[635] = work.v[470];
var[636] = work.v[471];
var[637] = work.v[472];
var[638] = work.v[474];
var[639] = work.v[475];
var[640] = work.v[476];
var[641] = work.v[478];
var[642] = work.v[479];
var[643] = work.v[480];
var[644] = work.v[482];
var[645] = work.v[483];
var[646] = work.v[484];
var[647] = work.v[486];
var[648] = work.v[487];
var[649] = work.v[488];
var[650] = work.v[490];
var[651] = work.v[491];
var[652] = work.v[492];
var[653] = work.v[494];
var[654] = work.v[495];
var[655] = work.v[496];
var[656] = work.v[498];
var[657] = work.v[499];
var[658] = work.v[500];
var[659] = work.v[502];
var[660] = work.v[503];
var[661] = work.v[504];
var[662] = work.v[506];
var[663] = work.v[507];
var[664] = work.v[508];
var[665] = work.v[510];
var[666] = work.v[511];
var[667] = work.v[512];
var[668] = work.v[514];
var[669] = work.v[515];
var[670] = work.v[516];
var[671] = work.v[518];
var[672] = work.v[519];
var[673] = work.v[520];
var[674] = work.v[522];
var[675] = work.v[523];
var[676] = work.v[524];
var[677] = work.v[526];
var[678] = work.v[527];
var[679] = work.v[528];
var[680] = work.v[530];
var[681] = work.v[531];
var[682] = work.v[532];
var[683] = work.v[534];
var[684] = work.v[535];
var[685] = work.v[536];
var[686] = work.v[538];
var[687] = work.v[539];
var[688] = work.v[540];
var[689] = work.v[542];
var[690] = work.v[543];
var[691] = work.v[544];
var[692] = work.v[546];
var[693] = work.v[547];
var[694] = work.v[548];
var[695] = work.v[550];
var[696] = work.v[551];
var[697] = work.v[552];
var[698] = work.v[554];
var[699] = work.v[555];
var[700] = work.v[556];
var[701] = work.v[558];
var[702] = work.v[559];
var[703] = work.v[560];
var[704] = work.v[562];
var[705] = work.v[563];
var[706] = work.v[564];
var[707] = work.v[566];
var[708] = work.v[567];
var[709] = work.v[568];
var[710] = work.v[570];
var[711] = work.v[571];
var[712] = work.v[572];
var[713] = work.v[574];
var[714] = work.v[575];
var[715] = work.v[576];
var[716] = work.v[578];
var[717] = work.v[579];
var[718] = work.v[580];
var[719] = work.v[582];
var[720] = work.v[583];
var[721] = work.v[584];
var[722] = work.v[586];
var[723] = work.v[587];
var[724] = work.v[588];
var[725] = work.v[590];
var[726] = work.v[591];
var[727] = work.v[592];
var[728] = work.v[594];
var[729] = work.v[595];
var[730] = work.v[596];
var[731] = work.v[598];
var[732] = work.v[599];
var[733] = work.v[600];
var[734] = work.v[602];
var[735] = work.v[603];
var[736] = work.v[604];
var[737] = work.v[606];
var[738] = work.v[607];
var[739] = work.v[608];
var[740] = work.v[610];
var[741] = work.v[611];
var[742] = work.v[612];
var[743] = work.v[614];
var[744] = work.v[615];
var[745] = work.v[616];
var[746] = work.v[618];
var[747] = work.v[619];
var[748] = work.v[620];
var[749] = work.v[622];
var[750] = work.v[623];
var[751] = work.v[624];
var[752] = work.v[626];
var[753] = work.v[627];
var[754] = work.v[629];
var[755] = work.v[631];
var[756] = work.v[632];
var[757] = work.v[633];
var[758] = work.v[635];
var[759] = work.v[636];
var[760] = work.v[637];
var[761] = work.v[639];
var[762] = work.v[640];
var[763] = work.v[641];
var[764] = work.v[643];
var[765] = work.v[644];
var[766] = work.v[645];
var[767] = work.v[647];
var[768] = work.v[648];
var[769] = work.v[649];
var[770] = work.v[651];
var[771] = work.v[652];
var[772] = work.v[653];
var[773] = work.v[655];
var[774] = work.v[656];
var[775] = work.v[657];
var[776] = work.v[659];
var[777] = work.v[660];
var[778] = work.v[661];
var[779] = work.v[663];
var[780] = work.v[664];
var[781] = work.v[665];
var[782] = work.v[667];
var[783] = work.v[668];
var[784] = work.v[669];
var[785] = work.v[671];
var[786] = work.v[672];
var[787] = work.v[673];
var[788] = work.v[675];
var[789] = work.v[676];
var[790] = work.v[677];
var[791] = work.v[679];
var[792] = work.v[680];
var[793] = work.v[681];
var[794] = work.v[683];
var[795] = work.v[684];
var[796] = work.v[685];
var[797] = work.v[687];
var[798] = work.v[688];
var[799] = work.v[689];
var[800] = work.v[691];
var[801] = work.v[692];
var[802] = work.v[693];
var[803] = work.v[695];
var[804] = work.v[696];
var[805] = work.v[697];
var[806] = work.v[699];
var[807] = work.v[700];
var[808] = work.v[701];
var[809] = work.v[703];
var[810] = work.v[704];
var[811] = work.v[705];
var[812] = work.v[707];
var[813] = work.v[708];
var[814] = work.v[709];
var[815] = work.v[711];
var[816] = work.v[712];
var[817] = work.v[713];
var[818] = work.v[715];
var[819] = work.v[716];
var[820] = work.v[717];
var[821] = work.v[719];
var[822] = work.v[720];
var[823] = work.v[721];
var[824] = work.v[723];
var[825] = work.v[724];
var[826] = work.v[725];
var[827] = work.v[727];
var[828] = work.v[728];
var[829] = work.v[729];
var[830] = work.v[731];
var[831] = work.v[732];
var[832] = work.v[312];
var[833] = work.v[313];
var[834] = work.v[735];
var[835] = work.v[737];
var[836] = work.v[766];
var[837] = work.v[767];
var[838] = work.v[769];
var[839] = work.v[780];
var[840] = work.v[770];
var[841] = work.v[783];
var[842] = work.v[781];
var[843] = work.v[785];
var[844] = work.v[789];
var[845] = work.v[787];
var[846] = work.v[791];
var[847] = work.v[795];
var[848] = work.v[793];
var[849] = work.v[797];
var[850] = work.v[801];
var[851] = work.v[799];
var[852] = work.v[803];
var[853] = work.v[807];
var[854] = work.v[805];
var[855] = work.v[809];
var[856] = work.v[813];
var[857] = work.v[811];
var[858] = work.v[815];
var[859] = work.v[819];
var[860] = work.v[817];
var[861] = work.v[821];
var[862] = work.v[825];
var[863] = work.v[823];
var[864] = work.v[827];
var[865] = work.v[831];
var[866] = work.v[829];
var[867] = work.v[833];
var[868] = work.v[837];
var[869] = work.v[835];
var[870] = work.v[839];
var[871] = work.v[843];
var[872] = work.v[841];
var[873] = work.v[845];
var[874] = work.v[849];
var[875] = work.v[847];
var[876] = work.v[851];
var[877] = work.v[855];
var[878] = work.v[853];
var[879] = work.v[857];
var[880] = work.v[861];
var[881] = work.v[859];
var[882] = work.v[863];
var[883] = work.v[867];
var[884] = work.v[865];
var[885] = work.v[869];
var[886] = work.v[873];
var[887] = work.v[871];
var[888] = work.v[875];
var[889] = work.v[879];
var[890] = work.v[877];
var[891] = work.v[881];
var[892] = work.v[885];
var[893] = work.v[883];
var[894] = work.v[887];
var[895] = work.v[891];
var[896] = work.v[889];
var[897] = work.v[893];
var[898] = work.v[897];
var[899] = work.v[895];
var[900] = work.v[899];
var[901] = work.v[905];
var[902] = work.v[906];
var[903] = work.v[774];
var[904] = work.v[776];
var[905] = work.v[775];
var[906] = work.v[771];
var[907] = work.v[738];
var[908] = work.v[739];
var[909] = work.v[740];
#ifndef ZERO_LIBRARY_MODE
if (settings.debug) {
printf("Squared norm for solution is %.8g.\n", check_residual(target, var));
}
#endif
}
void ldl_factor(void) {
work.d[0] = work.KKT[0];
if (work.d[0] < 0)
work.d[0] = settings.kkt_reg;
else
work.d[0] += settings.kkt_reg;
work.d_inv[0] = 1/work.d[0];
work.L[1] = work.KKT[1]*work.d_inv[0];
work.v[1] = work.KKT[2];
work.d[1] = work.v[1];
if (work.d[1] < 0)
work.d[1] = settings.kkt_reg;
else
work.d[1] += settings.kkt_reg;
work.d_inv[1] = 1/work.d[1];
work.L[3] = (work.KKT[3])*work.d_inv[1];
work.v[2] = work.KKT[4];
work.d[2] = work.v[2];
if (work.d[2] < 0)
work.d[2] = settings.kkt_reg;
else
work.d[2] += settings.kkt_reg;
work.d_inv[2] = 1/work.d[2];
work.L[5] = (work.KKT[5])*work.d_inv[2];
work.v[3] = work.KKT[6];
work.d[3] = work.v[3];
if (work.d[3] < 0)
work.d[3] = settings.kkt_reg;
else
work.d[3] += settings.kkt_reg;
work.d_inv[3] = 1/work.d[3];
work.L[8] = (work.KKT[7])*work.d_inv[3];
work.v[4] = work.KKT[8];
work.d[4] = work.v[4];
if (work.d[4] < 0)
work.d[4] = settings.kkt_reg;
else
work.d[4] += settings.kkt_reg;
work.d_inv[4] = 1/work.d[4];
work.L[10] = (work.KKT[9])*work.d_inv[4];
work.v[5] = work.KKT[10];
work.d[5] = work.v[5];
if (work.d[5] < 0)
work.d[5] = settings.kkt_reg;
else
work.d[5] += settings.kkt_reg;
work.d_inv[5] = 1/work.d[5];
work.L[12] = (work.KKT[11])*work.d_inv[5];
work.v[6] = work.KKT[12];
work.d[6] = work.v[6];
if (work.d[6] < 0)
work.d[6] = settings.kkt_reg;
else
work.d[6] += settings.kkt_reg;
work.d_inv[6] = 1/work.d[6];
work.L[15] = (work.KKT[13])*work.d_inv[6];
work.v[7] = work.KKT[14];
work.d[7] = work.v[7];
if (work.d[7] < 0)
work.d[7] = settings.kkt_reg;
else
work.d[7] += settings.kkt_reg;
work.d_inv[7] = 1/work.d[7];
work.L[17] = (work.KKT[15])*work.d_inv[7];
work.v[8] = work.KKT[16];
work.d[8] = work.v[8];
if (work.d[8] < 0)
work.d[8] = settings.kkt_reg;
else
work.d[8] += settings.kkt_reg;
work.d_inv[8] = 1/work.d[8];
work.L[19] = (work.KKT[17])*work.d_inv[8];
work.v[9] = work.KKT[18];
work.d[9] = work.v[9];
if (work.d[9] < 0)
work.d[9] = settings.kkt_reg;
else
work.d[9] += settings.kkt_reg;
work.d_inv[9] = 1/work.d[9];
work.L[22] = (work.KKT[19])*work.d_inv[9];
work.v[10] = work.KKT[20];
work.d[10] = work.v[10];
if (work.d[10] < 0)
work.d[10] = settings.kkt_reg;
else
work.d[10] += settings.kkt_reg;
work.d_inv[10] = 1/work.d[10];
work.L[24] = (work.KKT[21])*work.d_inv[10];
work.v[11] = work.KKT[22];
work.d[11] = work.v[11];
if (work.d[11] < 0)
work.d[11] = settings.kkt_reg;
else
work.d[11] += settings.kkt_reg;
work.d_inv[11] = 1/work.d[11];
work.L[26] = (work.KKT[23])*work.d_inv[11];
work.v[12] = work.KKT[24];
work.d[12] = work.v[12];
if (work.d[12] < 0)
work.d[12] = settings.kkt_reg;
else
work.d[12] += settings.kkt_reg;
work.d_inv[12] = 1/work.d[12];
work.L[29] = (work.KKT[25])*work.d_inv[12];
work.v[13] = work.KKT[26];
work.d[13] = work.v[13];
if (work.d[13] < 0)
work.d[13] = settings.kkt_reg;
else
work.d[13] += settings.kkt_reg;
work.d_inv[13] = 1/work.d[13];
work.L[31] = (work.KKT[27])*work.d_inv[13];
work.v[14] = work.KKT[28];
work.d[14] = work.v[14];
if (work.d[14] < 0)
work.d[14] = settings.kkt_reg;
else
work.d[14] += settings.kkt_reg;
work.d_inv[14] = 1/work.d[14];
work.L[33] = (work.KKT[29])*work.d_inv[14];
work.v[15] = work.KKT[30];
work.d[15] = work.v[15];
if (work.d[15] < 0)
work.d[15] = settings.kkt_reg;
else
work.d[15] += settings.kkt_reg;
work.d_inv[15] = 1/work.d[15];
work.L[36] = (work.KKT[31])*work.d_inv[15];
work.v[16] = work.KKT[32];
work.d[16] = work.v[16];
if (work.d[16] < 0)
work.d[16] = settings.kkt_reg;
else
work.d[16] += settings.kkt_reg;
work.d_inv[16] = 1/work.d[16];
work.L[38] = (work.KKT[33])*work.d_inv[16];
work.v[17] = work.KKT[34];
work.d[17] = work.v[17];
if (work.d[17] < 0)
work.d[17] = settings.kkt_reg;
else
work.d[17] += settings.kkt_reg;
work.d_inv[17] = 1/work.d[17];
work.L[40] = (work.KKT[35])*work.d_inv[17];
work.v[18] = work.KKT[36];
work.d[18] = work.v[18];
if (work.d[18] < 0)
work.d[18] = settings.kkt_reg;
else
work.d[18] += settings.kkt_reg;
work.d_inv[18] = 1/work.d[18];
work.L[43] = (work.KKT[37])*work.d_inv[18];
work.v[19] = work.KKT[38];
work.d[19] = work.v[19];
if (work.d[19] < 0)
work.d[19] = settings.kkt_reg;
else
work.d[19] += settings.kkt_reg;
work.d_inv[19] = 1/work.d[19];
work.L[45] = (work.KKT[39])*work.d_inv[19];
work.v[20] = work.KKT[40];
work.d[20] = work.v[20];
if (work.d[20] < 0)
work.d[20] = settings.kkt_reg;
else
work.d[20] += settings.kkt_reg;
work.d_inv[20] = 1/work.d[20];
work.L[47] = (work.KKT[41])*work.d_inv[20];
work.v[21] = work.KKT[42];
work.d[21] = work.v[21];
if (work.d[21] < 0)
work.d[21] = settings.kkt_reg;
else
work.d[21] += settings.kkt_reg;
work.d_inv[21] = 1/work.d[21];
work.L[50] = (work.KKT[43])*work.d_inv[21];
work.v[22] = work.KKT[44];
work.d[22] = work.v[22];
if (work.d[22] < 0)
work.d[22] = settings.kkt_reg;
else
work.d[22] += settings.kkt_reg;
work.d_inv[22] = 1/work.d[22];
work.L[52] = (work.KKT[45])*work.d_inv[22];
work.v[23] = work.KKT[46];
work.d[23] = work.v[23];
if (work.d[23] < 0)
work.d[23] = settings.kkt_reg;
else
work.d[23] += settings.kkt_reg;
work.d_inv[23] = 1/work.d[23];
work.L[54] = (work.KKT[47])*work.d_inv[23];
work.v[24] = work.KKT[48];
work.d[24] = work.v[24];
if (work.d[24] < 0)
work.d[24] = settings.kkt_reg;
else
work.d[24] += settings.kkt_reg;
work.d_inv[24] = 1/work.d[24];
work.L[57] = (work.KKT[49])*work.d_inv[24];
work.v[25] = work.KKT[50];
work.d[25] = work.v[25];
if (work.d[25] < 0)
work.d[25] = settings.kkt_reg;
else
work.d[25] += settings.kkt_reg;
work.d_inv[25] = 1/work.d[25];
work.L[59] = (work.KKT[51])*work.d_inv[25];
work.v[26] = work.KKT[52];
work.d[26] = work.v[26];
if (work.d[26] < 0)
work.d[26] = settings.kkt_reg;
else
work.d[26] += settings.kkt_reg;
work.d_inv[26] = 1/work.d[26];
work.L[61] = (work.KKT[53])*work.d_inv[26];
work.v[27] = work.KKT[54];
work.d[27] = work.v[27];
if (work.d[27] < 0)
work.d[27] = settings.kkt_reg;
else
work.d[27] += settings.kkt_reg;
work.d_inv[27] = 1/work.d[27];
work.L[64] = (work.KKT[55])*work.d_inv[27];
work.v[28] = work.KKT[56];
work.d[28] = work.v[28];
if (work.d[28] < 0)
work.d[28] = settings.kkt_reg;
else
work.d[28] += settings.kkt_reg;
work.d_inv[28] = 1/work.d[28];
work.L[66] = (work.KKT[57])*work.d_inv[28];
work.v[29] = work.KKT[58];
work.d[29] = work.v[29];
if (work.d[29] < 0)
work.d[29] = settings.kkt_reg;
else
work.d[29] += settings.kkt_reg;
work.d_inv[29] = 1/work.d[29];
work.L[68] = (work.KKT[59])*work.d_inv[29];
work.v[30] = work.KKT[60];
work.d[30] = work.v[30];
if (work.d[30] < 0)
work.d[30] = settings.kkt_reg;
else
work.d[30] += settings.kkt_reg;
work.d_inv[30] = 1/work.d[30];
work.L[71] = (work.KKT[61])*work.d_inv[30];
work.v[31] = work.KKT[62];
work.d[31] = work.v[31];
if (work.d[31] < 0)
work.d[31] = settings.kkt_reg;
else
work.d[31] += settings.kkt_reg;
work.d_inv[31] = 1/work.d[31];
work.L[73] = (work.KKT[63])*work.d_inv[31];
work.v[32] = work.KKT[64];
work.d[32] = work.v[32];
if (work.d[32] < 0)
work.d[32] = settings.kkt_reg;
else
work.d[32] += settings.kkt_reg;
work.d_inv[32] = 1/work.d[32];
work.L[75] = (work.KKT[65])*work.d_inv[32];
work.v[33] = work.KKT[66];
work.d[33] = work.v[33];
if (work.d[33] < 0)
work.d[33] = settings.kkt_reg;
else
work.d[33] += settings.kkt_reg;
work.d_inv[33] = 1/work.d[33];
work.L[78] = (work.KKT[67])*work.d_inv[33];
work.v[34] = work.KKT[68];
work.d[34] = work.v[34];
if (work.d[34] < 0)
work.d[34] = settings.kkt_reg;
else
work.d[34] += settings.kkt_reg;
work.d_inv[34] = 1/work.d[34];
work.L[80] = (work.KKT[69])*work.d_inv[34];
work.v[35] = work.KKT[70];
work.d[35] = work.v[35];
if (work.d[35] < 0)
work.d[35] = settings.kkt_reg;
else
work.d[35] += settings.kkt_reg;
work.d_inv[35] = 1/work.d[35];
work.L[82] = (work.KKT[71])*work.d_inv[35];
work.v[36] = work.KKT[72];
work.d[36] = work.v[36];
if (work.d[36] < 0)
work.d[36] = settings.kkt_reg;
else
work.d[36] += settings.kkt_reg;
work.d_inv[36] = 1/work.d[36];
work.L[85] = (work.KKT[73])*work.d_inv[36];
work.v[37] = work.KKT[74];
work.d[37] = work.v[37];
if (work.d[37] < 0)
work.d[37] = settings.kkt_reg;
else
work.d[37] += settings.kkt_reg;
work.d_inv[37] = 1/work.d[37];
work.L[87] = (work.KKT[75])*work.d_inv[37];
work.v[38] = work.KKT[76];
work.d[38] = work.v[38];
if (work.d[38] < 0)
work.d[38] = settings.kkt_reg;
else
work.d[38] += settings.kkt_reg;
work.d_inv[38] = 1/work.d[38];
work.L[89] = (work.KKT[77])*work.d_inv[38];
work.v[39] = work.KKT[78];
work.d[39] = work.v[39];
if (work.d[39] < 0)
work.d[39] = settings.kkt_reg;
else
work.d[39] += settings.kkt_reg;
work.d_inv[39] = 1/work.d[39];
work.L[92] = (work.KKT[79])*work.d_inv[39];
work.v[40] = work.KKT[80];
work.d[40] = work.v[40];
if (work.d[40] < 0)
work.d[40] = settings.kkt_reg;
else
work.d[40] += settings.kkt_reg;
work.d_inv[40] = 1/work.d[40];
work.L[94] = (work.KKT[81])*work.d_inv[40];
work.v[41] = work.KKT[82];
work.d[41] = work.v[41];
if (work.d[41] < 0)
work.d[41] = settings.kkt_reg;
else
work.d[41] += settings.kkt_reg;
work.d_inv[41] = 1/work.d[41];
work.L[96] = (work.KKT[83])*work.d_inv[41];
work.v[42] = work.KKT[84];
work.d[42] = work.v[42];
if (work.d[42] < 0)
work.d[42] = settings.kkt_reg;
else
work.d[42] += settings.kkt_reg;
work.d_inv[42] = 1/work.d[42];
work.L[99] = (work.KKT[85])*work.d_inv[42];
work.v[43] = work.KKT[86];
work.d[43] = work.v[43];
if (work.d[43] < 0)
work.d[43] = settings.kkt_reg;
else
work.d[43] += settings.kkt_reg;
work.d_inv[43] = 1/work.d[43];
work.L[101] = (work.KKT[87])*work.d_inv[43];
work.v[44] = work.KKT[88];
work.d[44] = work.v[44];
if (work.d[44] < 0)
work.d[44] = settings.kkt_reg;
else
work.d[44] += settings.kkt_reg;
work.d_inv[44] = 1/work.d[44];
work.L[103] = (work.KKT[89])*work.d_inv[44];
work.v[45] = work.KKT[90];
work.d[45] = work.v[45];
if (work.d[45] < 0)
work.d[45] = settings.kkt_reg;
else
work.d[45] += settings.kkt_reg;
work.d_inv[45] = 1/work.d[45];
work.L[106] = (work.KKT[91])*work.d_inv[45];
work.v[46] = work.KKT[92];
work.d[46] = work.v[46];
if (work.d[46] < 0)
work.d[46] = settings.kkt_reg;
else
work.d[46] += settings.kkt_reg;
work.d_inv[46] = 1/work.d[46];
work.L[108] = (work.KKT[93])*work.d_inv[46];
work.v[47] = work.KKT[94];
work.d[47] = work.v[47];
if (work.d[47] < 0)
work.d[47] = settings.kkt_reg;
else
work.d[47] += settings.kkt_reg;
work.d_inv[47] = 1/work.d[47];
work.L[110] = (work.KKT[95])*work.d_inv[47];
work.v[48] = work.KKT[96];
work.d[48] = work.v[48];
if (work.d[48] < 0)
work.d[48] = settings.kkt_reg;
else
work.d[48] += settings.kkt_reg;
work.d_inv[48] = 1/work.d[48];
work.L[113] = (work.KKT[97])*work.d_inv[48];
work.v[49] = work.KKT[98];
work.d[49] = work.v[49];
if (work.d[49] < 0)
work.d[49] = settings.kkt_reg;
else
work.d[49] += settings.kkt_reg;
work.d_inv[49] = 1/work.d[49];
work.L[115] = (work.KKT[99])*work.d_inv[49];
work.v[50] = work.KKT[100];
work.d[50] = work.v[50];
if (work.d[50] < 0)
work.d[50] = settings.kkt_reg;
else
work.d[50] += settings.kkt_reg;
work.d_inv[50] = 1/work.d[50];
work.L[117] = (work.KKT[101])*work.d_inv[50];
work.v[51] = work.KKT[102];
work.d[51] = work.v[51];
if (work.d[51] < 0)
work.d[51] = settings.kkt_reg;
else
work.d[51] += settings.kkt_reg;
work.d_inv[51] = 1/work.d[51];
work.L[120] = (work.KKT[103])*work.d_inv[51];
work.v[52] = work.KKT[104];
work.d[52] = work.v[52];
if (work.d[52] < 0)
work.d[52] = settings.kkt_reg;
else
work.d[52] += settings.kkt_reg;
work.d_inv[52] = 1/work.d[52];
work.L[122] = (work.KKT[105])*work.d_inv[52];
work.v[53] = work.KKT[106];
work.d[53] = work.v[53];
if (work.d[53] < 0)
work.d[53] = settings.kkt_reg;
else
work.d[53] += settings.kkt_reg;
work.d_inv[53] = 1/work.d[53];
work.L[124] = (work.KKT[107])*work.d_inv[53];
work.v[54] = work.KKT[108];
work.d[54] = work.v[54];
if (work.d[54] < 0)
work.d[54] = settings.kkt_reg;
else
work.d[54] += settings.kkt_reg;
work.d_inv[54] = 1/work.d[54];
work.L[127] = (work.KKT[109])*work.d_inv[54];
work.v[55] = work.KKT[110];
work.d[55] = work.v[55];
if (work.d[55] < 0)
work.d[55] = settings.kkt_reg;
else
work.d[55] += settings.kkt_reg;
work.d_inv[55] = 1/work.d[55];
work.L[129] = (work.KKT[111])*work.d_inv[55];
work.v[56] = work.KKT[112];
work.d[56] = work.v[56];
if (work.d[56] < 0)
work.d[56] = settings.kkt_reg;
else
work.d[56] += settings.kkt_reg;
work.d_inv[56] = 1/work.d[56];
work.L[131] = (work.KKT[113])*work.d_inv[56];
work.v[57] = work.KKT[114];
work.d[57] = work.v[57];
if (work.d[57] < 0)
work.d[57] = settings.kkt_reg;
else
work.d[57] += settings.kkt_reg;
work.d_inv[57] = 1/work.d[57];
work.L[134] = (work.KKT[115])*work.d_inv[57];
work.v[58] = work.KKT[116];
work.d[58] = work.v[58];
if (work.d[58] < 0)
work.d[58] = settings.kkt_reg;
else
work.d[58] += settings.kkt_reg;
work.d_inv[58] = 1/work.d[58];
work.L[136] = (work.KKT[117])*work.d_inv[58];
work.v[59] = work.KKT[118];
work.d[59] = work.v[59];
if (work.d[59] < 0)
work.d[59] = settings.kkt_reg;
else
work.d[59] += settings.kkt_reg;
work.d_inv[59] = 1/work.d[59];
work.L[138] = (work.KKT[119])*work.d_inv[59];
work.v[60] = work.KKT[120];
work.d[60] = work.v[60];
if (work.d[60] < 0)
work.d[60] = settings.kkt_reg;
else
work.d[60] += settings.kkt_reg;
work.d_inv[60] = 1/work.d[60];
work.L[141] = (work.KKT[121])*work.d_inv[60];
work.v[61] = work.KKT[122];
work.d[61] = work.v[61];
if (work.d[61] < 0)
work.d[61] = settings.kkt_reg;
else
work.d[61] += settings.kkt_reg;
work.d_inv[61] = 1/work.d[61];
work.L[143] = (work.KKT[123])*work.d_inv[61];
work.v[62] = work.KKT[124];
work.d[62] = work.v[62];
if (work.d[62] < 0)
work.d[62] = settings.kkt_reg;
else
work.d[62] += settings.kkt_reg;
work.d_inv[62] = 1/work.d[62];
work.L[145] = (work.KKT[125])*work.d_inv[62];
work.v[63] = work.KKT[126];
work.d[63] = work.v[63];
if (work.d[63] < 0)
work.d[63] = settings.kkt_reg;
else
work.d[63] += settings.kkt_reg;
work.d_inv[63] = 1/work.d[63];
work.L[148] = (work.KKT[127])*work.d_inv[63];
work.v[64] = work.KKT[128];
work.d[64] = work.v[64];
if (work.d[64] < 0)
work.d[64] = settings.kkt_reg;
else
work.d[64] += settings.kkt_reg;
work.d_inv[64] = 1/work.d[64];
work.L[150] = (work.KKT[129])*work.d_inv[64];
work.v[65] = work.KKT[130];
work.d[65] = work.v[65];
if (work.d[65] < 0)
work.d[65] = settings.kkt_reg;
else
work.d[65] += settings.kkt_reg;
work.d_inv[65] = 1/work.d[65];
work.L[152] = (work.KKT[131])*work.d_inv[65];
work.v[66] = work.KKT[132];
work.d[66] = work.v[66];
if (work.d[66] < 0)
work.d[66] = settings.kkt_reg;
else
work.d[66] += settings.kkt_reg;
work.d_inv[66] = 1/work.d[66];
work.L[155] = (work.KKT[133])*work.d_inv[66];
work.v[67] = work.KKT[134];
work.d[67] = work.v[67];
if (work.d[67] < 0)
work.d[67] = settings.kkt_reg;
else
work.d[67] += settings.kkt_reg;
work.d_inv[67] = 1/work.d[67];
work.L[157] = (work.KKT[135])*work.d_inv[67];
work.v[68] = work.KKT[136];
work.d[68] = work.v[68];
if (work.d[68] < 0)
work.d[68] = settings.kkt_reg;
else
work.d[68] += settings.kkt_reg;
work.d_inv[68] = 1/work.d[68];
work.L[159] = (work.KKT[137])*work.d_inv[68];
work.v[69] = work.KKT[138];
work.d[69] = work.v[69];
if (work.d[69] < 0)
work.d[69] = settings.kkt_reg;
else
work.d[69] += settings.kkt_reg;
work.d_inv[69] = 1/work.d[69];
work.L[162] = (work.KKT[139])*work.d_inv[69];
work.v[70] = work.KKT[140];
work.d[70] = work.v[70];
if (work.d[70] < 0)
work.d[70] = settings.kkt_reg;
else
work.d[70] += settings.kkt_reg;
work.d_inv[70] = 1/work.d[70];
work.L[164] = (work.KKT[141])*work.d_inv[70];
work.v[71] = work.KKT[142];
work.d[71] = work.v[71];
if (work.d[71] < 0)
work.d[71] = settings.kkt_reg;
else
work.d[71] += settings.kkt_reg;
work.d_inv[71] = 1/work.d[71];
work.L[166] = (work.KKT[143])*work.d_inv[71];
work.v[72] = work.KKT[144];
work.d[72] = work.v[72];
if (work.d[72] < 0)
work.d[72] = settings.kkt_reg;
else
work.d[72] += settings.kkt_reg;
work.d_inv[72] = 1/work.d[72];
work.L[169] = (work.KKT[145])*work.d_inv[72];
work.v[73] = work.KKT[146];
work.d[73] = work.v[73];
if (work.d[73] < 0)
work.d[73] = settings.kkt_reg;
else
work.d[73] += settings.kkt_reg;
work.d_inv[73] = 1/work.d[73];
work.L[171] = (work.KKT[147])*work.d_inv[73];
work.v[74] = work.KKT[148];
work.d[74] = work.v[74];
if (work.d[74] < 0)
work.d[74] = settings.kkt_reg;
else
work.d[74] += settings.kkt_reg;
work.d_inv[74] = 1/work.d[74];
work.L[173] = (work.KKT[149])*work.d_inv[74];
work.v[75] = work.KKT[150];
work.d[75] = work.v[75];
if (work.d[75] < 0)
work.d[75] = settings.kkt_reg;
else
work.d[75] += settings.kkt_reg;
work.d_inv[75] = 1/work.d[75];
work.L[176] = (work.KKT[151])*work.d_inv[75];
work.v[76] = work.KKT[152];
work.d[76] = work.v[76];
if (work.d[76] < 0)
work.d[76] = settings.kkt_reg;
else
work.d[76] += settings.kkt_reg;
work.d_inv[76] = 1/work.d[76];
work.L[178] = (work.KKT[153])*work.d_inv[76];
work.v[77] = work.KKT[154];
work.d[77] = work.v[77];
if (work.d[77] < 0)
work.d[77] = settings.kkt_reg;
else
work.d[77] += settings.kkt_reg;
work.d_inv[77] = 1/work.d[77];
work.L[180] = (work.KKT[155])*work.d_inv[77];
work.v[78] = work.KKT[156];
work.d[78] = work.v[78];
if (work.d[78] < 0)
work.d[78] = settings.kkt_reg;
else
work.d[78] += settings.kkt_reg;
work.d_inv[78] = 1/work.d[78];
work.L[183] = (work.KKT[157])*work.d_inv[78];
work.v[79] = work.KKT[158];
work.d[79] = work.v[79];
if (work.d[79] < 0)
work.d[79] = settings.kkt_reg;
else
work.d[79] += settings.kkt_reg;
work.d_inv[79] = 1/work.d[79];
work.L[185] = (work.KKT[159])*work.d_inv[79];
work.v[80] = work.KKT[160];
work.d[80] = work.v[80];
if (work.d[80] < 0)
work.d[80] = settings.kkt_reg;
else
work.d[80] += settings.kkt_reg;
work.d_inv[80] = 1/work.d[80];
work.L[187] = (work.KKT[161])*work.d_inv[80];
work.v[81] = work.KKT[162];
work.d[81] = work.v[81];
if (work.d[81] < 0)
work.d[81] = settings.kkt_reg;
else
work.d[81] += settings.kkt_reg;
work.d_inv[81] = 1/work.d[81];
work.L[190] = (work.KKT[163])*work.d_inv[81];
work.v[82] = work.KKT[164];
work.d[82] = work.v[82];
if (work.d[82] < 0)
work.d[82] = settings.kkt_reg;
else
work.d[82] += settings.kkt_reg;
work.d_inv[82] = 1/work.d[82];
work.L[192] = (work.KKT[165])*work.d_inv[82];
work.v[83] = work.KKT[166];
work.d[83] = work.v[83];
if (work.d[83] < 0)
work.d[83] = settings.kkt_reg;
else
work.d[83] += settings.kkt_reg;
work.d_inv[83] = 1/work.d[83];
work.L[194] = (work.KKT[167])*work.d_inv[83];
work.v[84] = work.KKT[168];
work.d[84] = work.v[84];
if (work.d[84] < 0)
work.d[84] = settings.kkt_reg;
else
work.d[84] += settings.kkt_reg;
work.d_inv[84] = 1/work.d[84];
work.L[197] = (work.KKT[169])*work.d_inv[84];
work.v[85] = work.KKT[170];
work.d[85] = work.v[85];
if (work.d[85] < 0)
work.d[85] = settings.kkt_reg;
else
work.d[85] += settings.kkt_reg;
work.d_inv[85] = 1/work.d[85];
work.L[199] = (work.KKT[171])*work.d_inv[85];
work.v[86] = work.KKT[172];
work.d[86] = work.v[86];
if (work.d[86] < 0)
work.d[86] = settings.kkt_reg;
else
work.d[86] += settings.kkt_reg;
work.d_inv[86] = 1/work.d[86];
work.L[201] = (work.KKT[173])*work.d_inv[86];
work.v[87] = work.KKT[174];
work.d[87] = work.v[87];
if (work.d[87] < 0)
work.d[87] = settings.kkt_reg;
else
work.d[87] += settings.kkt_reg;
work.d_inv[87] = 1/work.d[87];
work.L[204] = (work.KKT[175])*work.d_inv[87];
work.v[88] = work.KKT[176];
work.d[88] = work.v[88];
if (work.d[88] < 0)
work.d[88] = settings.kkt_reg;
else
work.d[88] += settings.kkt_reg;
work.d_inv[88] = 1/work.d[88];
work.L[206] = (work.KKT[177])*work.d_inv[88];
work.v[89] = work.KKT[178];
work.d[89] = work.v[89];
if (work.d[89] < 0)
work.d[89] = settings.kkt_reg;
else
work.d[89] += settings.kkt_reg;
work.d_inv[89] = 1/work.d[89];
work.L[208] = (work.KKT[179])*work.d_inv[89];
work.v[90] = work.KKT[180];
work.d[90] = work.v[90];
if (work.d[90] < 0)
work.d[90] = settings.kkt_reg;
else
work.d[90] += settings.kkt_reg;
work.d_inv[90] = 1/work.d[90];
work.L[211] = (work.KKT[181])*work.d_inv[90];
work.v[91] = work.KKT[182];
work.d[91] = work.v[91];
if (work.d[91] < 0)
work.d[91] = settings.kkt_reg;
else
work.d[91] += settings.kkt_reg;
work.d_inv[91] = 1/work.d[91];
work.L[213] = (work.KKT[183])*work.d_inv[91];
work.v[92] = work.KKT[184];
work.d[92] = work.v[92];
if (work.d[92] < 0)
work.d[92] = settings.kkt_reg;
else
work.d[92] += settings.kkt_reg;
work.d_inv[92] = 1/work.d[92];
work.L[215] = (work.KKT[185])*work.d_inv[92];
work.v[93] = work.KKT[186];
work.d[93] = work.v[93];
if (work.d[93] < 0)
work.d[93] = settings.kkt_reg;
else
work.d[93] += settings.kkt_reg;
work.d_inv[93] = 1/work.d[93];
work.L[218] = (work.KKT[187])*work.d_inv[93];
work.v[94] = work.KKT[188];
work.d[94] = work.v[94];
if (work.d[94] < 0)
work.d[94] = settings.kkt_reg;
else
work.d[94] += settings.kkt_reg;
work.d_inv[94] = 1/work.d[94];
work.L[220] = (work.KKT[189])*work.d_inv[94];
work.v[95] = work.KKT[190];
work.d[95] = work.v[95];
if (work.d[95] < 0)
work.d[95] = settings.kkt_reg;
else
work.d[95] += settings.kkt_reg;
work.d_inv[95] = 1/work.d[95];
work.L[222] = (work.KKT[191])*work.d_inv[95];
work.v[96] = work.KKT[192];
work.d[96] = work.v[96];
if (work.d[96] < 0)
work.d[96] = settings.kkt_reg;
else
work.d[96] += settings.kkt_reg;
work.d_inv[96] = 1/work.d[96];
work.L[225] = (work.KKT[193])*work.d_inv[96];
work.v[97] = work.KKT[194];
work.d[97] = work.v[97];
if (work.d[97] < 0)
work.d[97] = settings.kkt_reg;
else
work.d[97] += settings.kkt_reg;
work.d_inv[97] = 1/work.d[97];
work.L[227] = (work.KKT[195])*work.d_inv[97];
work.v[98] = work.KKT[196];
work.d[98] = work.v[98];
if (work.d[98] < 0)
work.d[98] = settings.kkt_reg;
else
work.d[98] += settings.kkt_reg;
work.d_inv[98] = 1/work.d[98];
work.L[229] = (work.KKT[197])*work.d_inv[98];
work.v[99] = work.KKT[198];
work.d[99] = work.v[99];
if (work.d[99] < 0)
work.d[99] = settings.kkt_reg;
else
work.d[99] += settings.kkt_reg;
work.d_inv[99] = 1/work.d[99];
work.L[232] = (work.KKT[199])*work.d_inv[99];
work.v[100] = work.KKT[200];
work.d[100] = work.v[100];
if (work.d[100] < 0)
work.d[100] = settings.kkt_reg;
else
work.d[100] += settings.kkt_reg;
work.d_inv[100] = 1/work.d[100];
work.L[234] = (work.KKT[201])*work.d_inv[100];
work.v[101] = work.KKT[202];
work.d[101] = work.v[101];
if (work.d[101] < 0)
work.d[101] = settings.kkt_reg;
else
work.d[101] += settings.kkt_reg;
work.d_inv[101] = 1/work.d[101];
work.L[236] = (work.KKT[203])*work.d_inv[101];
work.v[102] = work.KKT[204];
work.d[102] = work.v[102];
if (work.d[102] < 0)
work.d[102] = settings.kkt_reg;
else
work.d[102] += settings.kkt_reg;
work.d_inv[102] = 1/work.d[102];
work.L[239] = (work.KKT[205])*work.d_inv[102];
work.v[103] = work.KKT[206];
work.d[103] = work.v[103];
if (work.d[103] < 0)
work.d[103] = settings.kkt_reg;
else
work.d[103] += settings.kkt_reg;
work.d_inv[103] = 1/work.d[103];
work.L[241] = (work.KKT[207])*work.d_inv[103];
work.v[104] = work.KKT[208];
work.d[104] = work.v[104];
if (work.d[104] < 0)
work.d[104] = settings.kkt_reg;
else
work.d[104] += settings.kkt_reg;
work.d_inv[104] = 1/work.d[104];
work.L[243] = (work.KKT[209])*work.d_inv[104];
work.v[105] = work.KKT[210];
work.d[105] = work.v[105];
if (work.d[105] < 0)
work.d[105] = settings.kkt_reg;
else
work.d[105] += settings.kkt_reg;
work.d_inv[105] = 1/work.d[105];
work.L[246] = (work.KKT[211])*work.d_inv[105];
work.v[106] = work.KKT[212];
work.d[106] = work.v[106];
if (work.d[106] < 0)
work.d[106] = settings.kkt_reg;
else
work.d[106] += settings.kkt_reg;
work.d_inv[106] = 1/work.d[106];
work.L[248] = (work.KKT[213])*work.d_inv[106];
work.v[107] = work.KKT[214];
work.d[107] = work.v[107];
if (work.d[107] < 0)
work.d[107] = settings.kkt_reg;
else
work.d[107] += settings.kkt_reg;
work.d_inv[107] = 1/work.d[107];
work.L[250] = (work.KKT[215])*work.d_inv[107];
work.v[108] = work.KKT[216];
work.d[108] = work.v[108];
if (work.d[108] < 0)
work.d[108] = settings.kkt_reg;
else
work.d[108] += settings.kkt_reg;
work.d_inv[108] = 1/work.d[108];
work.L[253] = (work.KKT[217])*work.d_inv[108];
work.v[109] = work.KKT[218];
work.d[109] = work.v[109];
if (work.d[109] < 0)
work.d[109] = settings.kkt_reg;
else
work.d[109] += settings.kkt_reg;
work.d_inv[109] = 1/work.d[109];
work.L[255] = (work.KKT[219])*work.d_inv[109];
work.v[110] = work.KKT[220];
work.d[110] = work.v[110];
if (work.d[110] < 0)
work.d[110] = settings.kkt_reg;
else
work.d[110] += settings.kkt_reg;
work.d_inv[110] = 1/work.d[110];
work.L[257] = (work.KKT[221])*work.d_inv[110];
work.v[111] = work.KKT[222];
work.d[111] = work.v[111];
if (work.d[111] < 0)
work.d[111] = settings.kkt_reg;
else
work.d[111] += settings.kkt_reg;
work.d_inv[111] = 1/work.d[111];
work.L[260] = (work.KKT[223])*work.d_inv[111];
work.v[112] = work.KKT[224];
work.d[112] = work.v[112];
if (work.d[112] < 0)
work.d[112] = settings.kkt_reg;
else
work.d[112] += settings.kkt_reg;
work.d_inv[112] = 1/work.d[112];
work.L[262] = (work.KKT[225])*work.d_inv[112];
work.v[113] = work.KKT[226];
work.d[113] = work.v[113];
if (work.d[113] < 0)
work.d[113] = settings.kkt_reg;
else
work.d[113] += settings.kkt_reg;
work.d_inv[113] = 1/work.d[113];
work.L[264] = (work.KKT[227])*work.d_inv[113];
work.v[114] = work.KKT[228];
work.d[114] = work.v[114];
if (work.d[114] < 0)
work.d[114] = settings.kkt_reg;
else
work.d[114] += settings.kkt_reg;
work.d_inv[114] = 1/work.d[114];
work.L[267] = (work.KKT[229])*work.d_inv[114];
work.v[115] = work.KKT[230];
work.d[115] = work.v[115];
if (work.d[115] < 0)
work.d[115] = settings.kkt_reg;
else
work.d[115] += settings.kkt_reg;
work.d_inv[115] = 1/work.d[115];
work.L[269] = (work.KKT[231])*work.d_inv[115];
work.v[116] = work.KKT[232];
work.d[116] = work.v[116];
if (work.d[116] < 0)
work.d[116] = settings.kkt_reg;
else
work.d[116] += settings.kkt_reg;
work.d_inv[116] = 1/work.d[116];
work.L[271] = (work.KKT[233])*work.d_inv[116];
work.v[117] = work.KKT[234];
work.d[117] = work.v[117];
if (work.d[117] < 0)
work.d[117] = settings.kkt_reg;
else
work.d[117] += settings.kkt_reg;
work.d_inv[117] = 1/work.d[117];
work.L[274] = (work.KKT[235])*work.d_inv[117];
work.v[118] = work.KKT[236];
work.d[118] = work.v[118];
if (work.d[118] < 0)
work.d[118] = settings.kkt_reg;
else
work.d[118] += settings.kkt_reg;
work.d_inv[118] = 1/work.d[118];
work.L[276] = (work.KKT[237])*work.d_inv[118];
work.v[119] = work.KKT[238];
work.d[119] = work.v[119];
if (work.d[119] < 0)
work.d[119] = settings.kkt_reg;
else
work.d[119] += settings.kkt_reg;
work.d_inv[119] = 1/work.d[119];
work.L[278] = (work.KKT[239])*work.d_inv[119];
work.v[120] = work.KKT[240];
work.d[120] = work.v[120];
if (work.d[120] < 0)
work.d[120] = settings.kkt_reg;
else
work.d[120] += settings.kkt_reg;
work.d_inv[120] = 1/work.d[120];
work.L[281] = (work.KKT[241])*work.d_inv[120];
work.v[121] = work.KKT[242];
work.d[121] = work.v[121];
if (work.d[121] < 0)
work.d[121] = settings.kkt_reg;
else
work.d[121] += settings.kkt_reg;
work.d_inv[121] = 1/work.d[121];
work.L[283] = (work.KKT[243])*work.d_inv[121];
work.v[122] = work.KKT[244];
work.d[122] = work.v[122];
if (work.d[122] < 0)
work.d[122] = settings.kkt_reg;
else
work.d[122] += settings.kkt_reg;
work.d_inv[122] = 1/work.d[122];
work.L[285] = (work.KKT[245])*work.d_inv[122];
work.v[123] = work.KKT[246];
work.d[123] = work.v[123];
if (work.d[123] < 0)
work.d[123] = settings.kkt_reg;
else
work.d[123] += settings.kkt_reg;
work.d_inv[123] = 1/work.d[123];
work.L[288] = (work.KKT[247])*work.d_inv[123];
work.v[124] = work.KKT[248];
work.d[124] = work.v[124];
if (work.d[124] < 0)
work.d[124] = settings.kkt_reg;
else
work.d[124] += settings.kkt_reg;
work.d_inv[124] = 1/work.d[124];
work.L[290] = (work.KKT[249])*work.d_inv[124];
work.v[125] = work.KKT[250];
work.d[125] = work.v[125];
if (work.d[125] < 0)
work.d[125] = settings.kkt_reg;
else
work.d[125] += settings.kkt_reg;
work.d_inv[125] = 1/work.d[125];
work.L[292] = (work.KKT[251])*work.d_inv[125];
work.v[126] = work.KKT[252];
work.d[126] = work.v[126];
if (work.d[126] < 0)
work.d[126] = settings.kkt_reg;
else
work.d[126] += settings.kkt_reg;
work.d_inv[126] = 1/work.d[126];
work.L[295] = (work.KKT[253])*work.d_inv[126];
work.v[127] = work.KKT[254];
work.d[127] = work.v[127];
if (work.d[127] < 0)
work.d[127] = settings.kkt_reg;
else
work.d[127] += settings.kkt_reg;
work.d_inv[127] = 1/work.d[127];
work.L[297] = (work.KKT[255])*work.d_inv[127];
work.v[128] = work.KKT[256];
work.d[128] = work.v[128];
if (work.d[128] < 0)
work.d[128] = settings.kkt_reg;
else
work.d[128] += settings.kkt_reg;
work.d_inv[128] = 1/work.d[128];
work.L[299] = (work.KKT[257])*work.d_inv[128];
work.v[129] = work.KKT[258];
work.d[129] = work.v[129];
if (work.d[129] < 0)
work.d[129] = settings.kkt_reg;
else
work.d[129] += settings.kkt_reg;
work.d_inv[129] = 1/work.d[129];
work.L[302] = (work.KKT[259])*work.d_inv[129];
work.v[130] = work.KKT[260];
work.d[130] = work.v[130];
if (work.d[130] < 0)
work.d[130] = settings.kkt_reg;
else
work.d[130] += settings.kkt_reg;
work.d_inv[130] = 1/work.d[130];
work.L[304] = (work.KKT[261])*work.d_inv[130];
work.v[131] = work.KKT[262];
work.d[131] = work.v[131];
if (work.d[131] < 0)
work.d[131] = settings.kkt_reg;
else
work.d[131] += settings.kkt_reg;
work.d_inv[131] = 1/work.d[131];
work.L[306] = (work.KKT[263])*work.d_inv[131];
work.v[132] = work.KKT[264];
work.d[132] = work.v[132];
if (work.d[132] < 0)
work.d[132] = settings.kkt_reg;
else
work.d[132] += settings.kkt_reg;
work.d_inv[132] = 1/work.d[132];
work.L[309] = (work.KKT[265])*work.d_inv[132];
work.v[133] = work.KKT[266];
work.d[133] = work.v[133];
if (work.d[133] < 0)
work.d[133] = settings.kkt_reg;
else
work.d[133] += settings.kkt_reg;
work.d_inv[133] = 1/work.d[133];
work.L[311] = (work.KKT[267])*work.d_inv[133];
work.v[134] = work.KKT[268];
work.d[134] = work.v[134];
if (work.d[134] < 0)
work.d[134] = settings.kkt_reg;
else
work.d[134] += settings.kkt_reg;
work.d_inv[134] = 1/work.d[134];
work.L[313] = (work.KKT[269])*work.d_inv[134];
work.v[135] = work.KKT[270];
work.d[135] = work.v[135];
if (work.d[135] < 0)
work.d[135] = settings.kkt_reg;
else
work.d[135] += settings.kkt_reg;
work.d_inv[135] = 1/work.d[135];
work.L[316] = (work.KKT[271])*work.d_inv[135];
work.v[136] = work.KKT[272];
work.d[136] = work.v[136];
if (work.d[136] < 0)
work.d[136] = settings.kkt_reg;
else
work.d[136] += settings.kkt_reg;
work.d_inv[136] = 1/work.d[136];
work.L[318] = (work.KKT[273])*work.d_inv[136];
work.v[137] = work.KKT[274];
work.d[137] = work.v[137];
if (work.d[137] < 0)
work.d[137] = settings.kkt_reg;
else
work.d[137] += settings.kkt_reg;
work.d_inv[137] = 1/work.d[137];
work.L[320] = (work.KKT[275])*work.d_inv[137];
work.v[138] = work.KKT[276];
work.d[138] = work.v[138];
if (work.d[138] < 0)
work.d[138] = settings.kkt_reg;
else
work.d[138] += settings.kkt_reg;
work.d_inv[138] = 1/work.d[138];
work.L[323] = (work.KKT[277])*work.d_inv[138];
work.v[139] = work.KKT[278];
work.d[139] = work.v[139];
if (work.d[139] < 0)
work.d[139] = settings.kkt_reg;
else
work.d[139] += settings.kkt_reg;
work.d_inv[139] = 1/work.d[139];
work.L[325] = (work.KKT[279])*work.d_inv[139];
work.v[140] = work.KKT[280];
work.d[140] = work.v[140];
if (work.d[140] < 0)
work.d[140] = settings.kkt_reg;
else
work.d[140] += settings.kkt_reg;
work.d_inv[140] = 1/work.d[140];
work.L[327] = (work.KKT[281])*work.d_inv[140];
work.v[141] = work.KKT[282];
work.d[141] = work.v[141];
if (work.d[141] < 0)
work.d[141] = settings.kkt_reg;
else
work.d[141] += settings.kkt_reg;
work.d_inv[141] = 1/work.d[141];
work.L[330] = (work.KKT[283])*work.d_inv[141];
work.v[142] = work.KKT[284];
work.d[142] = work.v[142];
if (work.d[142] < 0)
work.d[142] = settings.kkt_reg;
else
work.d[142] += settings.kkt_reg;
work.d_inv[142] = 1/work.d[142];
work.L[332] = (work.KKT[285])*work.d_inv[142];
work.v[143] = work.KKT[286];
work.d[143] = work.v[143];
if (work.d[143] < 0)
work.d[143] = settings.kkt_reg;
else
work.d[143] += settings.kkt_reg;
work.d_inv[143] = 1/work.d[143];
work.L[334] = (work.KKT[287])*work.d_inv[143];
work.v[144] = work.KKT[288];
work.d[144] = work.v[144];
if (work.d[144] < 0)
work.d[144] = settings.kkt_reg;
else
work.d[144] += settings.kkt_reg;
work.d_inv[144] = 1/work.d[144];
work.L[337] = (work.KKT[289])*work.d_inv[144];
work.v[145] = work.KKT[290];
work.d[145] = work.v[145];
if (work.d[145] < 0)
work.d[145] = settings.kkt_reg;
else
work.d[145] += settings.kkt_reg;
work.d_inv[145] = 1/work.d[145];
work.L[339] = (work.KKT[291])*work.d_inv[145];
work.v[146] = work.KKT[292];
work.d[146] = work.v[146];
if (work.d[146] < 0)
work.d[146] = settings.kkt_reg;
else
work.d[146] += settings.kkt_reg;
work.d_inv[146] = 1/work.d[146];
work.L[341] = (work.KKT[293])*work.d_inv[146];
work.v[147] = work.KKT[294];
work.d[147] = work.v[147];
if (work.d[147] < 0)
work.d[147] = settings.kkt_reg;
else
work.d[147] += settings.kkt_reg;
work.d_inv[147] = 1/work.d[147];
work.L[344] = (work.KKT[295])*work.d_inv[147];
work.v[148] = work.KKT[296];
work.d[148] = work.v[148];
if (work.d[148] < 0)
work.d[148] = settings.kkt_reg;
else
work.d[148] += settings.kkt_reg;
work.d_inv[148] = 1/work.d[148];
work.L[346] = (work.KKT[297])*work.d_inv[148];
work.v[149] = work.KKT[298];
work.d[149] = work.v[149];
if (work.d[149] < 0)
work.d[149] = settings.kkt_reg;
else
work.d[149] += settings.kkt_reg;
work.d_inv[149] = 1/work.d[149];
work.L[348] = (work.KKT[299])*work.d_inv[149];
work.v[150] = work.KKT[300];
work.d[150] = work.v[150];
if (work.d[150] < 0)
work.d[150] = settings.kkt_reg;
else
work.d[150] += settings.kkt_reg;
work.d_inv[150] = 1/work.d[150];
work.L[351] = (work.KKT[301])*work.d_inv[150];
work.v[151] = work.KKT[302];
work.d[151] = work.v[151];
if (work.d[151] < 0)
work.d[151] = settings.kkt_reg;
else
work.d[151] += settings.kkt_reg;
work.d_inv[151] = 1/work.d[151];
work.L[353] = (work.KKT[303])*work.d_inv[151];
work.v[152] = work.KKT[304];
work.d[152] = work.v[152];
if (work.d[152] < 0)
work.d[152] = settings.kkt_reg;
else
work.d[152] += settings.kkt_reg;
work.d_inv[152] = 1/work.d[152];
work.L[355] = (work.KKT[305])*work.d_inv[152];
work.v[153] = work.KKT[306];
work.d[153] = work.v[153];
if (work.d[153] < 0)
work.d[153] = settings.kkt_reg;
else
work.d[153] += settings.kkt_reg;
work.d_inv[153] = 1/work.d[153];
work.L[358] = (work.KKT[307])*work.d_inv[153];
work.v[154] = work.KKT[308];
work.d[154] = work.v[154];
if (work.d[154] < 0)
work.d[154] = settings.kkt_reg;
else
work.d[154] += settings.kkt_reg;
work.d_inv[154] = 1/work.d[154];
work.L[360] = (work.KKT[309])*work.d_inv[154];
work.v[155] = work.KKT[310];
work.d[155] = work.v[155];
if (work.d[155] < 0)
work.d[155] = settings.kkt_reg;
else
work.d[155] += settings.kkt_reg;
work.d_inv[155] = 1/work.d[155];
work.L[362] = (work.KKT[311])*work.d_inv[155];
work.v[156] = work.KKT[312];
work.d[156] = work.v[156];
if (work.d[156] < 0)
work.d[156] = settings.kkt_reg;
else
work.d[156] += settings.kkt_reg;
work.d_inv[156] = 1/work.d[156];
work.L[365] = (work.KKT[313])*work.d_inv[156];
work.v[157] = work.KKT[314];
work.d[157] = work.v[157];
if (work.d[157] < 0)
work.d[157] = settings.kkt_reg;
else
work.d[157] += settings.kkt_reg;
work.d_inv[157] = 1/work.d[157];
work.L[367] = (work.KKT[315])*work.d_inv[157];
work.v[158] = work.KKT[316];
work.d[158] = work.v[158];
if (work.d[158] < 0)
work.d[158] = settings.kkt_reg;
else
work.d[158] += settings.kkt_reg;
work.d_inv[158] = 1/work.d[158];
work.L[369] = (work.KKT[317])*work.d_inv[158];
work.v[159] = work.KKT[318];
work.d[159] = work.v[159];
if (work.d[159] < 0)
work.d[159] = settings.kkt_reg;
else
work.d[159] += settings.kkt_reg;
work.d_inv[159] = 1/work.d[159];
work.L[372] = (work.KKT[319])*work.d_inv[159];
work.v[160] = work.KKT[320];
work.d[160] = work.v[160];
if (work.d[160] < 0)
work.d[160] = settings.kkt_reg;
else
work.d[160] += settings.kkt_reg;
work.d_inv[160] = 1/work.d[160];
work.L[374] = (work.KKT[321])*work.d_inv[160];
work.v[161] = work.KKT[322];
work.d[161] = work.v[161];
if (work.d[161] < 0)
work.d[161] = settings.kkt_reg;
else
work.d[161] += settings.kkt_reg;
work.d_inv[161] = 1/work.d[161];
work.L[376] = (work.KKT[323])*work.d_inv[161];
work.v[162] = work.KKT[324];
work.d[162] = work.v[162];
if (work.d[162] < 0)
work.d[162] = settings.kkt_reg;
else
work.d[162] += settings.kkt_reg;
work.d_inv[162] = 1/work.d[162];
work.L[379] = (work.KKT[325])*work.d_inv[162];
work.v[163] = work.KKT[326];
work.d[163] = work.v[163];
if (work.d[163] < 0)
work.d[163] = settings.kkt_reg;
else
work.d[163] += settings.kkt_reg;
work.d_inv[163] = 1/work.d[163];
work.L[381] = (work.KKT[327])*work.d_inv[163];
work.v[164] = work.KKT[328];
work.d[164] = work.v[164];
if (work.d[164] < 0)
work.d[164] = settings.kkt_reg;
else
work.d[164] += settings.kkt_reg;
work.d_inv[164] = 1/work.d[164];
work.L[383] = (work.KKT[329])*work.d_inv[164];
work.v[165] = work.KKT[330];
work.d[165] = work.v[165];
if (work.d[165] < 0)
work.d[165] = settings.kkt_reg;
else
work.d[165] += settings.kkt_reg;
work.d_inv[165] = 1/work.d[165];
work.L[386] = (work.KKT[331])*work.d_inv[165];
work.v[166] = work.KKT[332];
work.d[166] = work.v[166];
if (work.d[166] < 0)
work.d[166] = settings.kkt_reg;
else
work.d[166] += settings.kkt_reg;
work.d_inv[166] = 1/work.d[166];
work.L[388] = (work.KKT[333])*work.d_inv[166];
work.v[167] = work.KKT[334];
work.d[167] = work.v[167];
if (work.d[167] < 0)
work.d[167] = settings.kkt_reg;
else
work.d[167] += settings.kkt_reg;
work.d_inv[167] = 1/work.d[167];
work.L[390] = (work.KKT[335])*work.d_inv[167];
work.v[168] = work.KKT[336];
work.d[168] = work.v[168];
if (work.d[168] < 0)
work.d[168] = settings.kkt_reg;
else
work.d[168] += settings.kkt_reg;
work.d_inv[168] = 1/work.d[168];
work.L[393] = (work.KKT[337])*work.d_inv[168];
work.v[169] = work.KKT[338];
work.d[169] = work.v[169];
if (work.d[169] < 0)
work.d[169] = settings.kkt_reg;
else
work.d[169] += settings.kkt_reg;
work.d_inv[169] = 1/work.d[169];
work.L[395] = (work.KKT[339])*work.d_inv[169];
work.v[170] = work.KKT[340];
work.d[170] = work.v[170];
if (work.d[170] < 0)
work.d[170] = settings.kkt_reg;
else
work.d[170] += settings.kkt_reg;
work.d_inv[170] = 1/work.d[170];
work.L[397] = (work.KKT[341])*work.d_inv[170];
work.v[171] = work.KKT[342];
work.d[171] = work.v[171];
if (work.d[171] < 0)
work.d[171] = settings.kkt_reg;
else
work.d[171] += settings.kkt_reg;
work.d_inv[171] = 1/work.d[171];
work.L[400] = (work.KKT[343])*work.d_inv[171];
work.v[172] = work.KKT[344];
work.d[172] = work.v[172];
if (work.d[172] < 0)
work.d[172] = settings.kkt_reg;
else
work.d[172] += settings.kkt_reg;
work.d_inv[172] = 1/work.d[172];
work.L[402] = (work.KKT[345])*work.d_inv[172];
work.v[173] = work.KKT[346];
work.d[173] = work.v[173];
if (work.d[173] < 0)
work.d[173] = settings.kkt_reg;
else
work.d[173] += settings.kkt_reg;
work.d_inv[173] = 1/work.d[173];
work.L[404] = (work.KKT[347])*work.d_inv[173];
work.v[174] = work.KKT[348];
work.d[174] = work.v[174];
if (work.d[174] < 0)
work.d[174] = settings.kkt_reg;
else
work.d[174] += settings.kkt_reg;
work.d_inv[174] = 1/work.d[174];
work.L[407] = (work.KKT[349])*work.d_inv[174];
work.v[175] = work.KKT[350];
work.d[175] = work.v[175];
if (work.d[175] < 0)
work.d[175] = settings.kkt_reg;
else
work.d[175] += settings.kkt_reg;
work.d_inv[175] = 1/work.d[175];
work.L[409] = (work.KKT[351])*work.d_inv[175];
work.v[176] = work.KKT[352];
work.d[176] = work.v[176];
if (work.d[176] < 0)
work.d[176] = settings.kkt_reg;
else
work.d[176] += settings.kkt_reg;
work.d_inv[176] = 1/work.d[176];
work.L[411] = (work.KKT[353])*work.d_inv[176];
work.v[177] = work.KKT[354];
work.d[177] = work.v[177];
if (work.d[177] < 0)
work.d[177] = settings.kkt_reg;
else
work.d[177] += settings.kkt_reg;
work.d_inv[177] = 1/work.d[177];
work.L[414] = (work.KKT[355])*work.d_inv[177];
work.v[178] = work.KKT[356];
work.d[178] = work.v[178];
if (work.d[178] < 0)
work.d[178] = settings.kkt_reg;
else
work.d[178] += settings.kkt_reg;
work.d_inv[178] = 1/work.d[178];
work.L[416] = (work.KKT[357])*work.d_inv[178];
work.v[179] = work.KKT[358];
work.d[179] = work.v[179];
if (work.d[179] < 0)
work.d[179] = settings.kkt_reg;
else
work.d[179] += settings.kkt_reg;
work.d_inv[179] = 1/work.d[179];
work.L[418] = (work.KKT[359])*work.d_inv[179];
work.v[180] = work.KKT[360];
work.d[180] = work.v[180];
if (work.d[180] < 0)
work.d[180] = settings.kkt_reg;
else
work.d[180] += settings.kkt_reg;
work.d_inv[180] = 1/work.d[180];
work.L[421] = (work.KKT[361])*work.d_inv[180];
work.v[181] = work.KKT[362];
work.d[181] = work.v[181];
if (work.d[181] < 0)
work.d[181] = settings.kkt_reg;
else
work.d[181] += settings.kkt_reg;
work.d_inv[181] = 1/work.d[181];
work.L[423] = (work.KKT[363])*work.d_inv[181];
work.v[182] = work.KKT[364];
work.d[182] = work.v[182];
if (work.d[182] < 0)
work.d[182] = settings.kkt_reg;
else
work.d[182] += settings.kkt_reg;
work.d_inv[182] = 1/work.d[182];
work.L[425] = (work.KKT[365])*work.d_inv[182];
work.v[183] = work.KKT[366];
work.d[183] = work.v[183];
if (work.d[183] < 0)
work.d[183] = settings.kkt_reg;
else
work.d[183] += settings.kkt_reg;
work.d_inv[183] = 1/work.d[183];
work.L[428] = (work.KKT[367])*work.d_inv[183];
work.v[184] = work.KKT[368];
work.d[184] = work.v[184];
if (work.d[184] < 0)
work.d[184] = settings.kkt_reg;
else
work.d[184] += settings.kkt_reg;
work.d_inv[184] = 1/work.d[184];
work.L[430] = (work.KKT[369])*work.d_inv[184];
work.v[185] = work.KKT[370];
work.d[185] = work.v[185];
if (work.d[185] < 0)
work.d[185] = settings.kkt_reg;
else
work.d[185] += settings.kkt_reg;
work.d_inv[185] = 1/work.d[185];
work.L[432] = (work.KKT[371])*work.d_inv[185];
work.v[186] = work.KKT[372];
work.d[186] = work.v[186];
if (work.d[186] < 0)
work.d[186] = settings.kkt_reg;
else
work.d[186] += settings.kkt_reg;
work.d_inv[186] = 1/work.d[186];
work.L[435] = (work.KKT[373])*work.d_inv[186];
work.v[187] = work.KKT[374];
work.d[187] = work.v[187];
if (work.d[187] < 0)
work.d[187] = settings.kkt_reg;
else
work.d[187] += settings.kkt_reg;
work.d_inv[187] = 1/work.d[187];
work.L[437] = (work.KKT[375])*work.d_inv[187];
work.v[188] = work.KKT[376];
work.d[188] = work.v[188];
if (work.d[188] < 0)
work.d[188] = settings.kkt_reg;
else
work.d[188] += settings.kkt_reg;
work.d_inv[188] = 1/work.d[188];
work.L[439] = (work.KKT[377])*work.d_inv[188];
work.v[189] = work.KKT[378];
work.d[189] = work.v[189];
if (work.d[189] < 0)
work.d[189] = settings.kkt_reg;
else
work.d[189] += settings.kkt_reg;
work.d_inv[189] = 1/work.d[189];
work.L[442] = (work.KKT[379])*work.d_inv[189];
work.v[190] = work.KKT[380];
work.d[190] = work.v[190];
if (work.d[190] < 0)
work.d[190] = settings.kkt_reg;
else
work.d[190] += settings.kkt_reg;
work.d_inv[190] = 1/work.d[190];
work.L[444] = (work.KKT[381])*work.d_inv[190];
work.v[191] = work.KKT[382];
work.d[191] = work.v[191];
if (work.d[191] < 0)
work.d[191] = settings.kkt_reg;
else
work.d[191] += settings.kkt_reg;
work.d_inv[191] = 1/work.d[191];
work.L[446] = (work.KKT[383])*work.d_inv[191];
work.v[192] = work.KKT[384];
work.d[192] = work.v[192];
if (work.d[192] < 0)
work.d[192] = settings.kkt_reg;
else
work.d[192] += settings.kkt_reg;
work.d_inv[192] = 1/work.d[192];
work.L[449] = (work.KKT[385])*work.d_inv[192];
work.v[193] = work.KKT[386];
work.d[193] = work.v[193];
if (work.d[193] < 0)
work.d[193] = settings.kkt_reg;
else
work.d[193] += settings.kkt_reg;
work.d_inv[193] = 1/work.d[193];
work.L[451] = (work.KKT[387])*work.d_inv[193];
work.v[194] = work.KKT[388];
work.d[194] = work.v[194];
if (work.d[194] < 0)
work.d[194] = settings.kkt_reg;
else
work.d[194] += settings.kkt_reg;
work.d_inv[194] = 1/work.d[194];
work.L[453] = (work.KKT[389])*work.d_inv[194];
work.v[195] = work.KKT[390];
work.d[195] = work.v[195];
if (work.d[195] < 0)
work.d[195] = settings.kkt_reg;
else
work.d[195] += settings.kkt_reg;
work.d_inv[195] = 1/work.d[195];
work.L[456] = (work.KKT[391])*work.d_inv[195];
work.v[196] = work.KKT[392];
work.d[196] = work.v[196];
if (work.d[196] < 0)
work.d[196] = settings.kkt_reg;
else
work.d[196] += settings.kkt_reg;
work.d_inv[196] = 1/work.d[196];
work.L[458] = (work.KKT[393])*work.d_inv[196];
work.v[197] = work.KKT[394];
work.d[197] = work.v[197];
if (work.d[197] < 0)
work.d[197] = settings.kkt_reg;
else
work.d[197] += settings.kkt_reg;
work.d_inv[197] = 1/work.d[197];
work.L[460] = (work.KKT[395])*work.d_inv[197];
work.v[198] = work.KKT[396];
work.d[198] = work.v[198];
if (work.d[198] < 0)
work.d[198] = settings.kkt_reg;
else
work.d[198] += settings.kkt_reg;
work.d_inv[198] = 1/work.d[198];
work.L[463] = (work.KKT[397])*work.d_inv[198];
work.v[199] = work.KKT[398];
work.d[199] = work.v[199];
if (work.d[199] < 0)
work.d[199] = settings.kkt_reg;
else
work.d[199] += settings.kkt_reg;
work.d_inv[199] = 1/work.d[199];
work.L[465] = (work.KKT[399])*work.d_inv[199];
work.v[200] = work.KKT[400];
work.d[200] = work.v[200];
if (work.d[200] < 0)
work.d[200] = settings.kkt_reg;
else
work.d[200] += settings.kkt_reg;
work.d_inv[200] = 1/work.d[200];
work.L[467] = (work.KKT[401])*work.d_inv[200];
work.v[201] = work.KKT[402];
work.d[201] = work.v[201];
if (work.d[201] < 0)
work.d[201] = settings.kkt_reg;
else
work.d[201] += settings.kkt_reg;
work.d_inv[201] = 1/work.d[201];
work.L[470] = (work.KKT[403])*work.d_inv[201];
work.v[202] = work.KKT[404];
work.d[202] = work.v[202];
if (work.d[202] < 0)
work.d[202] = settings.kkt_reg;
else
work.d[202] += settings.kkt_reg;
work.d_inv[202] = 1/work.d[202];
work.L[472] = (work.KKT[405])*work.d_inv[202];
work.v[203] = work.KKT[406];
work.d[203] = work.v[203];
if (work.d[203] < 0)
work.d[203] = settings.kkt_reg;
else
work.d[203] += settings.kkt_reg;
work.d_inv[203] = 1/work.d[203];
work.L[474] = (work.KKT[407])*work.d_inv[203];
work.v[204] = work.KKT[408];
work.d[204] = work.v[204];
if (work.d[204] < 0)
work.d[204] = settings.kkt_reg;
else
work.d[204] += settings.kkt_reg;
work.d_inv[204] = 1/work.d[204];
work.L[477] = (work.KKT[409])*work.d_inv[204];
work.v[205] = work.KKT[410];
work.d[205] = work.v[205];
if (work.d[205] < 0)
work.d[205] = settings.kkt_reg;
else
work.d[205] += settings.kkt_reg;
work.d_inv[205] = 1/work.d[205];
work.L[479] = (work.KKT[411])*work.d_inv[205];
work.v[206] = work.KKT[412];
work.d[206] = work.v[206];
if (work.d[206] < 0)
work.d[206] = settings.kkt_reg;
else
work.d[206] += settings.kkt_reg;
work.d_inv[206] = 1/work.d[206];
work.L[481] = (work.KKT[413])*work.d_inv[206];
work.v[207] = work.KKT[414];
work.d[207] = work.v[207];
if (work.d[207] < 0)
work.d[207] = settings.kkt_reg;
else
work.d[207] += settings.kkt_reg;
work.d_inv[207] = 1/work.d[207];
work.L[484] = (work.KKT[415])*work.d_inv[207];
work.v[208] = work.KKT[416];
work.d[208] = work.v[208];
if (work.d[208] < 0)
work.d[208] = settings.kkt_reg;
else
work.d[208] += settings.kkt_reg;
work.d_inv[208] = 1/work.d[208];
work.L[486] = (work.KKT[417])*work.d_inv[208];
work.v[209] = work.KKT[418];
work.d[209] = work.v[209];
if (work.d[209] < 0)
work.d[209] = settings.kkt_reg;
else
work.d[209] += settings.kkt_reg;
work.d_inv[209] = 1/work.d[209];
work.L[488] = (work.KKT[419])*work.d_inv[209];
work.v[210] = work.KKT[420];
work.d[210] = work.v[210];
if (work.d[210] < 0)
work.d[210] = settings.kkt_reg;
else
work.d[210] += settings.kkt_reg;
work.d_inv[210] = 1/work.d[210];
work.L[491] = (work.KKT[421])*work.d_inv[210];
work.v[211] = work.KKT[422];
work.d[211] = work.v[211];
if (work.d[211] < 0)
work.d[211] = settings.kkt_reg;
else
work.d[211] += settings.kkt_reg;
work.d_inv[211] = 1/work.d[211];
work.L[493] = (work.KKT[423])*work.d_inv[211];
work.v[212] = work.KKT[424];
work.d[212] = work.v[212];
if (work.d[212] < 0)
work.d[212] = settings.kkt_reg;
else
work.d[212] += settings.kkt_reg;
work.d_inv[212] = 1/work.d[212];
work.L[495] = (work.KKT[425])*work.d_inv[212];
work.v[213] = work.KKT[426];
work.d[213] = work.v[213];
if (work.d[213] < 0)
work.d[213] = settings.kkt_reg;
else
work.d[213] += settings.kkt_reg;
work.d_inv[213] = 1/work.d[213];
work.L[498] = (work.KKT[427])*work.d_inv[213];
work.v[214] = work.KKT[428];
work.d[214] = work.v[214];
if (work.d[214] < 0)
work.d[214] = settings.kkt_reg;
else
work.d[214] += settings.kkt_reg;
work.d_inv[214] = 1/work.d[214];
work.L[500] = (work.KKT[429])*work.d_inv[214];
work.v[215] = work.KKT[430];
work.d[215] = work.v[215];
if (work.d[215] < 0)
work.d[215] = settings.kkt_reg;
else
work.d[215] += settings.kkt_reg;
work.d_inv[215] = 1/work.d[215];
work.L[502] = (work.KKT[431])*work.d_inv[215];
work.v[216] = work.KKT[432];
work.d[216] = work.v[216];
if (work.d[216] < 0)
work.d[216] = settings.kkt_reg;
else
work.d[216] += settings.kkt_reg;
work.d_inv[216] = 1/work.d[216];
work.L[505] = (work.KKT[433])*work.d_inv[216];
work.v[217] = work.KKT[434];
work.d[217] = work.v[217];
if (work.d[217] < 0)
work.d[217] = settings.kkt_reg;
else
work.d[217] += settings.kkt_reg;
work.d_inv[217] = 1/work.d[217];
work.L[507] = (work.KKT[435])*work.d_inv[217];
work.v[218] = work.KKT[436];
work.d[218] = work.v[218];
if (work.d[218] < 0)
work.d[218] = settings.kkt_reg;
else
work.d[218] += settings.kkt_reg;
work.d_inv[218] = 1/work.d[218];
work.L[509] = (work.KKT[437])*work.d_inv[218];
work.v[219] = work.KKT[438];
work.d[219] = work.v[219];
if (work.d[219] < 0)
work.d[219] = settings.kkt_reg;
else
work.d[219] += settings.kkt_reg;
work.d_inv[219] = 1/work.d[219];
work.L[512] = (work.KKT[439])*work.d_inv[219];
work.v[220] = work.KKT[440];
work.d[220] = work.v[220];
if (work.d[220] < 0)
work.d[220] = settings.kkt_reg;
else
work.d[220] += settings.kkt_reg;
work.d_inv[220] = 1/work.d[220];
work.L[514] = (work.KKT[441])*work.d_inv[220];
work.v[221] = work.KKT[442];
work.d[221] = work.v[221];
if (work.d[221] < 0)
work.d[221] = settings.kkt_reg;
else
work.d[221] += settings.kkt_reg;
work.d_inv[221] = 1/work.d[221];
work.L[516] = (work.KKT[443])*work.d_inv[221];
work.v[222] = work.KKT[444];
work.d[222] = work.v[222];
if (work.d[222] < 0)
work.d[222] = settings.kkt_reg;
else
work.d[222] += settings.kkt_reg;
work.d_inv[222] = 1/work.d[222];
work.L[519] = (work.KKT[445])*work.d_inv[222];
work.v[223] = work.KKT[446];
work.d[223] = work.v[223];
if (work.d[223] < 0)
work.d[223] = settings.kkt_reg;
else
work.d[223] += settings.kkt_reg;
work.d_inv[223] = 1/work.d[223];
work.L[521] = (work.KKT[447])*work.d_inv[223];
work.v[224] = work.KKT[448];
work.d[224] = work.v[224];
if (work.d[224] < 0)
work.d[224] = settings.kkt_reg;
else
work.d[224] += settings.kkt_reg;
work.d_inv[224] = 1/work.d[224];
work.L[523] = (work.KKT[449])*work.d_inv[224];
work.v[225] = work.KKT[450];
work.d[225] = work.v[225];
if (work.d[225] < 0)
work.d[225] = settings.kkt_reg;
else
work.d[225] += settings.kkt_reg;
work.d_inv[225] = 1/work.d[225];
work.L[526] = (work.KKT[451])*work.d_inv[225];
work.v[226] = work.KKT[452];
work.d[226] = work.v[226];
if (work.d[226] < 0)
work.d[226] = settings.kkt_reg;
else
work.d[226] += settings.kkt_reg;
work.d_inv[226] = 1/work.d[226];
work.L[528] = (work.KKT[453])*work.d_inv[226];
work.v[227] = work.KKT[454];
work.d[227] = work.v[227];
if (work.d[227] < 0)
work.d[227] = settings.kkt_reg;
else
work.d[227] += settings.kkt_reg;
work.d_inv[227] = 1/work.d[227];
work.L[530] = (work.KKT[455])*work.d_inv[227];
work.v[228] = work.KKT[456];
work.d[228] = work.v[228];
if (work.d[228] < 0)
work.d[228] = settings.kkt_reg;
else
work.d[228] += settings.kkt_reg;
work.d_inv[228] = 1/work.d[228];
work.L[533] = (work.KKT[457])*work.d_inv[228];
work.v[229] = work.KKT[458];
work.d[229] = work.v[229];
if (work.d[229] < 0)
work.d[229] = settings.kkt_reg;
else
work.d[229] += settings.kkt_reg;
work.d_inv[229] = 1/work.d[229];
work.L[535] = (work.KKT[459])*work.d_inv[229];
work.v[230] = work.KKT[460];
work.d[230] = work.v[230];
if (work.d[230] < 0)
work.d[230] = settings.kkt_reg;
else
work.d[230] += settings.kkt_reg;
work.d_inv[230] = 1/work.d[230];
work.L[537] = (work.KKT[461])*work.d_inv[230];
work.v[231] = work.KKT[462];
work.d[231] = work.v[231];
if (work.d[231] < 0)
work.d[231] = settings.kkt_reg;
else
work.d[231] += settings.kkt_reg;
work.d_inv[231] = 1/work.d[231];
work.L[540] = (work.KKT[463])*work.d_inv[231];
work.v[232] = work.KKT[464];
work.d[232] = work.v[232];
if (work.d[232] < 0)
work.d[232] = settings.kkt_reg;
else
work.d[232] += settings.kkt_reg;
work.d_inv[232] = 1/work.d[232];
work.L[542] = (work.KKT[465])*work.d_inv[232];
work.v[233] = work.KKT[466];
work.d[233] = work.v[233];
if (work.d[233] < 0)
work.d[233] = settings.kkt_reg;
else
work.d[233] += settings.kkt_reg;
work.d_inv[233] = 1/work.d[233];
work.L[544] = (work.KKT[467])*work.d_inv[233];
work.v[234] = work.KKT[468];
work.d[234] = work.v[234];
if (work.d[234] < 0)
work.d[234] = settings.kkt_reg;
else
work.d[234] += settings.kkt_reg;
work.d_inv[234] = 1/work.d[234];
work.L[549] = (work.KKT[469])*work.d_inv[234];
work.v[235] = work.KKT[470];
work.d[235] = work.v[235];
if (work.d[235] < 0)
work.d[235] = settings.kkt_reg;
else
work.d[235] += settings.kkt_reg;
work.d_inv[235] = 1/work.d[235];
work.L[551] = (work.KKT[471])*work.d_inv[235];
work.v[236] = work.KKT[472];
work.d[236] = work.v[236];
if (work.d[236] < 0)
work.d[236] = settings.kkt_reg;
else
work.d[236] += settings.kkt_reg;
work.d_inv[236] = 1/work.d[236];
work.L[553] = (work.KKT[473])*work.d_inv[236];
work.v[237] = work.KKT[474];
work.d[237] = work.v[237];
if (work.d[237] < 0)
work.d[237] = settings.kkt_reg;
else
work.d[237] += settings.kkt_reg;
work.d_inv[237] = 1/work.d[237];
work.L[556] = (work.KKT[475])*work.d_inv[237];
work.v[238] = work.KKT[476];
work.d[238] = work.v[238];
if (work.d[238] < 0)
work.d[238] = settings.kkt_reg;
else
work.d[238] += settings.kkt_reg;
work.d_inv[238] = 1/work.d[238];
work.L[558] = (work.KKT[477])*work.d_inv[238];
work.v[239] = work.KKT[478];
work.d[239] = work.v[239];
if (work.d[239] < 0)
work.d[239] = settings.kkt_reg;
else
work.d[239] += settings.kkt_reg;
work.d_inv[239] = 1/work.d[239];
work.L[560] = (work.KKT[479])*work.d_inv[239];
work.v[240] = work.KKT[480];
work.d[240] = work.v[240];
if (work.d[240] < 0)
work.d[240] = settings.kkt_reg;
else
work.d[240] += settings.kkt_reg;
work.d_inv[240] = 1/work.d[240];
work.L[563] = (work.KKT[481])*work.d_inv[240];
work.v[241] = work.KKT[482];
work.d[241] = work.v[241];
if (work.d[241] < 0)
work.d[241] = settings.kkt_reg;
else
work.d[241] += settings.kkt_reg;
work.d_inv[241] = 1/work.d[241];
work.L[565] = (work.KKT[483])*work.d_inv[241];
work.v[242] = work.KKT[484];
work.d[242] = work.v[242];
if (work.d[242] < 0)
work.d[242] = settings.kkt_reg;
else
work.d[242] += settings.kkt_reg;
work.d_inv[242] = 1/work.d[242];
work.L[567] = (work.KKT[485])*work.d_inv[242];
work.v[243] = work.KKT[486];
work.d[243] = work.v[243];
if (work.d[243] < 0)
work.d[243] = settings.kkt_reg;
else
work.d[243] += settings.kkt_reg;
work.d_inv[243] = 1/work.d[243];
work.L[570] = (work.KKT[487])*work.d_inv[243];
work.v[244] = work.KKT[488];
work.d[244] = work.v[244];
if (work.d[244] < 0)
work.d[244] = settings.kkt_reg;
else
work.d[244] += settings.kkt_reg;
work.d_inv[244] = 1/work.d[244];
work.L[572] = (work.KKT[489])*work.d_inv[244];
work.v[245] = work.KKT[490];
work.d[245] = work.v[245];
if (work.d[245] < 0)
work.d[245] = settings.kkt_reg;
else
work.d[245] += settings.kkt_reg;
work.d_inv[245] = 1/work.d[245];
work.L[574] = (work.KKT[491])*work.d_inv[245];
work.v[246] = work.KKT[492];
work.d[246] = work.v[246];
if (work.d[246] < 0)
work.d[246] = settings.kkt_reg;
else
work.d[246] += settings.kkt_reg;
work.d_inv[246] = 1/work.d[246];
work.L[577] = (work.KKT[493])*work.d_inv[246];
work.v[247] = work.KKT[494];
work.d[247] = work.v[247];
if (work.d[247] < 0)
work.d[247] = settings.kkt_reg;
else
work.d[247] += settings.kkt_reg;
work.d_inv[247] = 1/work.d[247];
work.L[579] = (work.KKT[495])*work.d_inv[247];
work.v[248] = work.KKT[496];
work.d[248] = work.v[248];
if (work.d[248] < 0)
work.d[248] = settings.kkt_reg;
else
work.d[248] += settings.kkt_reg;
work.d_inv[248] = 1/work.d[248];
work.L[581] = (work.KKT[497])*work.d_inv[248];
work.v[249] = work.KKT[498];
work.d[249] = work.v[249];
if (work.d[249] < 0)
work.d[249] = settings.kkt_reg;
else
work.d[249] += settings.kkt_reg;
work.d_inv[249] = 1/work.d[249];
work.L[584] = (work.KKT[499])*work.d_inv[249];
work.v[250] = work.KKT[500];
work.d[250] = work.v[250];
if (work.d[250] < 0)
work.d[250] = settings.kkt_reg;
else
work.d[250] += settings.kkt_reg;
work.d_inv[250] = 1/work.d[250];
work.L[586] = (work.KKT[501])*work.d_inv[250];
work.v[251] = work.KKT[502];
work.d[251] = work.v[251];
if (work.d[251] < 0)
work.d[251] = settings.kkt_reg;
else
work.d[251] += settings.kkt_reg;
work.d_inv[251] = 1/work.d[251];
work.L[588] = (work.KKT[503])*work.d_inv[251];
work.v[252] = work.KKT[504];
work.d[252] = work.v[252];
if (work.d[252] < 0)
work.d[252] = settings.kkt_reg;
else
work.d[252] += settings.kkt_reg;
work.d_inv[252] = 1/work.d[252];
work.L[591] = (work.KKT[505])*work.d_inv[252];
work.v[253] = work.KKT[506];
work.d[253] = work.v[253];
if (work.d[253] < 0)
work.d[253] = settings.kkt_reg;
else
work.d[253] += settings.kkt_reg;
work.d_inv[253] = 1/work.d[253];
work.L[593] = (work.KKT[507])*work.d_inv[253];
work.v[254] = work.KKT[508];
work.d[254] = work.v[254];
if (work.d[254] < 0)
work.d[254] = settings.kkt_reg;
else
work.d[254] += settings.kkt_reg;
work.d_inv[254] = 1/work.d[254];
work.L[595] = (work.KKT[509])*work.d_inv[254];
work.v[255] = work.KKT[510];
work.d[255] = work.v[255];
if (work.d[255] < 0)
work.d[255] = settings.kkt_reg;
else
work.d[255] += settings.kkt_reg;
work.d_inv[255] = 1/work.d[255];
work.L[598] = (work.KKT[511])*work.d_inv[255];
work.v[256] = work.KKT[512];
work.d[256] = work.v[256];
if (work.d[256] < 0)
work.d[256] = settings.kkt_reg;
else
work.d[256] += settings.kkt_reg;
work.d_inv[256] = 1/work.d[256];
work.L[600] = (work.KKT[513])*work.d_inv[256];
work.v[257] = work.KKT[514];
work.d[257] = work.v[257];
if (work.d[257] < 0)
work.d[257] = settings.kkt_reg;
else
work.d[257] += settings.kkt_reg;
work.d_inv[257] = 1/work.d[257];
work.L[602] = (work.KKT[515])*work.d_inv[257];
work.v[258] = work.KKT[516];
work.d[258] = work.v[258];
if (work.d[258] < 0)
work.d[258] = settings.kkt_reg;
else
work.d[258] += settings.kkt_reg;
work.d_inv[258] = 1/work.d[258];
work.L[605] = (work.KKT[517])*work.d_inv[258];
work.v[259] = work.KKT[518];
work.d[259] = work.v[259];
if (work.d[259] < 0)
work.d[259] = settings.kkt_reg;
else
work.d[259] += settings.kkt_reg;
work.d_inv[259] = 1/work.d[259];
work.L[607] = (work.KKT[519])*work.d_inv[259];
work.v[260] = work.KKT[520];
work.d[260] = work.v[260];
if (work.d[260] < 0)
work.d[260] = settings.kkt_reg;
else
work.d[260] += settings.kkt_reg;
work.d_inv[260] = 1/work.d[260];
work.L[609] = (work.KKT[521])*work.d_inv[260];
work.v[261] = work.KKT[522];
work.d[261] = work.v[261];
if (work.d[261] < 0)
work.d[261] = settings.kkt_reg;
else
work.d[261] += settings.kkt_reg;
work.d_inv[261] = 1/work.d[261];
work.L[612] = (work.KKT[523])*work.d_inv[261];
work.v[262] = work.KKT[524];
work.d[262] = work.v[262];
if (work.d[262] < 0)
work.d[262] = settings.kkt_reg;
else
work.d[262] += settings.kkt_reg;
work.d_inv[262] = 1/work.d[262];
work.L[614] = (work.KKT[525])*work.d_inv[262];
work.v[263] = work.KKT[526];
work.d[263] = work.v[263];
if (work.d[263] < 0)
work.d[263] = settings.kkt_reg;
else
work.d[263] += settings.kkt_reg;
work.d_inv[263] = 1/work.d[263];
work.L[616] = (work.KKT[527])*work.d_inv[263];
work.v[264] = work.KKT[528];
work.d[264] = work.v[264];
if (work.d[264] < 0)
work.d[264] = settings.kkt_reg;
else
work.d[264] += settings.kkt_reg;
work.d_inv[264] = 1/work.d[264];
work.L[619] = (work.KKT[529])*work.d_inv[264];
work.v[265] = work.KKT[530];
work.d[265] = work.v[265];
if (work.d[265] < 0)
work.d[265] = settings.kkt_reg;
else
work.d[265] += settings.kkt_reg;
work.d_inv[265] = 1/work.d[265];
work.L[621] = (work.KKT[531])*work.d_inv[265];
work.v[266] = work.KKT[532];
work.d[266] = work.v[266];
if (work.d[266] < 0)
work.d[266] = settings.kkt_reg;
else
work.d[266] += settings.kkt_reg;
work.d_inv[266] = 1/work.d[266];
work.L[623] = (work.KKT[533])*work.d_inv[266];
work.v[267] = work.KKT[534];
work.d[267] = work.v[267];
if (work.d[267] < 0)
work.d[267] = settings.kkt_reg;
else
work.d[267] += settings.kkt_reg;
work.d_inv[267] = 1/work.d[267];
work.L[626] = (work.KKT[535])*work.d_inv[267];
work.v[268] = work.KKT[536];
work.d[268] = work.v[268];
if (work.d[268] < 0)
work.d[268] = settings.kkt_reg;
else
work.d[268] += settings.kkt_reg;
work.d_inv[268] = 1/work.d[268];
work.L[628] = (work.KKT[537])*work.d_inv[268];
work.v[269] = work.KKT[538];
work.d[269] = work.v[269];
if (work.d[269] < 0)
work.d[269] = settings.kkt_reg;
else
work.d[269] += settings.kkt_reg;
work.d_inv[269] = 1/work.d[269];
work.L[630] = (work.KKT[539])*work.d_inv[269];
work.v[270] = work.KKT[540];
work.d[270] = work.v[270];
if (work.d[270] < 0)
work.d[270] = settings.kkt_reg;
else
work.d[270] += settings.kkt_reg;
work.d_inv[270] = 1/work.d[270];
work.L[633] = (work.KKT[541])*work.d_inv[270];
work.v[271] = work.KKT[542];
work.d[271] = work.v[271];
if (work.d[271] < 0)
work.d[271] = settings.kkt_reg;
else
work.d[271] += settings.kkt_reg;
work.d_inv[271] = 1/work.d[271];
work.L[635] = (work.KKT[543])*work.d_inv[271];
work.v[272] = work.KKT[544];
work.d[272] = work.v[272];
if (work.d[272] < 0)
work.d[272] = settings.kkt_reg;
else
work.d[272] += settings.kkt_reg;
work.d_inv[272] = 1/work.d[272];
work.L[637] = (work.KKT[545])*work.d_inv[272];
work.v[273] = work.KKT[546];
work.d[273] = work.v[273];
if (work.d[273] < 0)
work.d[273] = settings.kkt_reg;
else
work.d[273] += settings.kkt_reg;
work.d_inv[273] = 1/work.d[273];
work.L[640] = (work.KKT[547])*work.d_inv[273];
work.v[274] = work.KKT[548];
work.d[274] = work.v[274];
if (work.d[274] < 0)
work.d[274] = settings.kkt_reg;
else
work.d[274] += settings.kkt_reg;
work.d_inv[274] = 1/work.d[274];
work.L[642] = (work.KKT[549])*work.d_inv[274];
work.v[275] = work.KKT[550];
work.d[275] = work.v[275];
if (work.d[275] < 0)
work.d[275] = settings.kkt_reg;
else
work.d[275] += settings.kkt_reg;
work.d_inv[275] = 1/work.d[275];
work.L[644] = (work.KKT[551])*work.d_inv[275];
work.v[276] = work.KKT[552];
work.d[276] = work.v[276];
if (work.d[276] < 0)
work.d[276] = settings.kkt_reg;
else
work.d[276] += settings.kkt_reg;
work.d_inv[276] = 1/work.d[276];
work.L[647] = (work.KKT[553])*work.d_inv[276];
work.v[277] = work.KKT[554];
work.d[277] = work.v[277];
if (work.d[277] < 0)
work.d[277] = settings.kkt_reg;
else
work.d[277] += settings.kkt_reg;
work.d_inv[277] = 1/work.d[277];
work.L[649] = (work.KKT[555])*work.d_inv[277];
work.v[278] = work.KKT[556];
work.d[278] = work.v[278];
if (work.d[278] < 0)
work.d[278] = settings.kkt_reg;
else
work.d[278] += settings.kkt_reg;
work.d_inv[278] = 1/work.d[278];
work.L[651] = (work.KKT[557])*work.d_inv[278];
work.v[279] = work.KKT[558];
work.d[279] = work.v[279];
if (work.d[279] < 0)
work.d[279] = settings.kkt_reg;
else
work.d[279] += settings.kkt_reg;
work.d_inv[279] = 1/work.d[279];
work.L[654] = (work.KKT[559])*work.d_inv[279];
work.v[280] = work.KKT[560];
work.d[280] = work.v[280];
if (work.d[280] < 0)
work.d[280] = settings.kkt_reg;
else
work.d[280] += settings.kkt_reg;
work.d_inv[280] = 1/work.d[280];
work.L[656] = (work.KKT[561])*work.d_inv[280];
work.v[281] = work.KKT[562];
work.d[281] = work.v[281];
if (work.d[281] < 0)
work.d[281] = settings.kkt_reg;
else
work.d[281] += settings.kkt_reg;
work.d_inv[281] = 1/work.d[281];
work.L[658] = (work.KKT[563])*work.d_inv[281];
work.v[282] = work.KKT[564];
work.d[282] = work.v[282];
if (work.d[282] < 0)
work.d[282] = settings.kkt_reg;
else
work.d[282] += settings.kkt_reg;
work.d_inv[282] = 1/work.d[282];
work.L[661] = (work.KKT[565])*work.d_inv[282];
work.v[283] = work.KKT[566];
work.d[283] = work.v[283];
if (work.d[283] < 0)
work.d[283] = settings.kkt_reg;
else
work.d[283] += settings.kkt_reg;
work.d_inv[283] = 1/work.d[283];
work.L[663] = (work.KKT[567])*work.d_inv[283];
work.v[284] = work.KKT[568];
work.d[284] = work.v[284];
if (work.d[284] < 0)
work.d[284] = settings.kkt_reg;
else
work.d[284] += settings.kkt_reg;
work.d_inv[284] = 1/work.d[284];
work.L[665] = (work.KKT[569])*work.d_inv[284];
work.v[285] = work.KKT[570];
work.d[285] = work.v[285];
if (work.d[285] < 0)
work.d[285] = settings.kkt_reg;
else
work.d[285] += settings.kkt_reg;
work.d_inv[285] = 1/work.d[285];
work.L[668] = (work.KKT[571])*work.d_inv[285];
work.v[286] = work.KKT[572];
work.d[286] = work.v[286];
if (work.d[286] < 0)
work.d[286] = settings.kkt_reg;
else
work.d[286] += settings.kkt_reg;
work.d_inv[286] = 1/work.d[286];
work.L[670] = (work.KKT[573])*work.d_inv[286];
work.v[287] = work.KKT[574];
work.d[287] = work.v[287];
if (work.d[287] < 0)
work.d[287] = settings.kkt_reg;
else
work.d[287] += settings.kkt_reg;
work.d_inv[287] = 1/work.d[287];
work.L[672] = (work.KKT[575])*work.d_inv[287];
work.v[288] = work.KKT[576];
work.d[288] = work.v[288];
if (work.d[288] < 0)
work.d[288] = settings.kkt_reg;
else
work.d[288] += settings.kkt_reg;
work.d_inv[288] = 1/work.d[288];
work.L[675] = (work.KKT[577])*work.d_inv[288];
work.v[289] = work.KKT[578];
work.d[289] = work.v[289];
if (work.d[289] < 0)
work.d[289] = settings.kkt_reg;
else
work.d[289] += settings.kkt_reg;
work.d_inv[289] = 1/work.d[289];
work.L[677] = (work.KKT[579])*work.d_inv[289];
work.v[290] = work.KKT[580];
work.d[290] = work.v[290];
if (work.d[290] < 0)
work.d[290] = settings.kkt_reg;
else
work.d[290] += settings.kkt_reg;
work.d_inv[290] = 1/work.d[290];
work.L[679] = (work.KKT[581])*work.d_inv[290];
work.v[291] = work.KKT[582];
work.d[291] = work.v[291];
if (work.d[291] < 0)
work.d[291] = settings.kkt_reg;
else
work.d[291] += settings.kkt_reg;
work.d_inv[291] = 1/work.d[291];
work.L[682] = (work.KKT[583])*work.d_inv[291];
work.v[292] = work.KKT[584];
work.d[292] = work.v[292];
if (work.d[292] < 0)
work.d[292] = settings.kkt_reg;
else
work.d[292] += settings.kkt_reg;
work.d_inv[292] = 1/work.d[292];
work.L[684] = (work.KKT[585])*work.d_inv[292];
work.v[293] = work.KKT[586];
work.d[293] = work.v[293];
if (work.d[293] < 0)
work.d[293] = settings.kkt_reg;
else
work.d[293] += settings.kkt_reg;
work.d_inv[293] = 1/work.d[293];
work.L[686] = (work.KKT[587])*work.d_inv[293];
work.v[294] = work.KKT[588];
work.d[294] = work.v[294];
if (work.d[294] < 0)
work.d[294] = settings.kkt_reg;
else
work.d[294] += settings.kkt_reg;
work.d_inv[294] = 1/work.d[294];
work.L[689] = (work.KKT[589])*work.d_inv[294];
work.v[295] = work.KKT[590];
work.d[295] = work.v[295];
if (work.d[295] < 0)
work.d[295] = settings.kkt_reg;
else
work.d[295] += settings.kkt_reg;
work.d_inv[295] = 1/work.d[295];
work.L[691] = (work.KKT[591])*work.d_inv[295];
work.v[296] = work.KKT[592];
work.d[296] = work.v[296];
if (work.d[296] < 0)
work.d[296] = settings.kkt_reg;
else
work.d[296] += settings.kkt_reg;
work.d_inv[296] = 1/work.d[296];
work.L[693] = (work.KKT[593])*work.d_inv[296];
work.v[297] = work.KKT[594];
work.d[297] = work.v[297];
if (work.d[297] < 0)
work.d[297] = settings.kkt_reg;
else
work.d[297] += settings.kkt_reg;
work.d_inv[297] = 1/work.d[297];
work.L[696] = (work.KKT[595])*work.d_inv[297];
work.v[298] = work.KKT[596];
work.d[298] = work.v[298];
if (work.d[298] < 0)
work.d[298] = settings.kkt_reg;
else
work.d[298] += settings.kkt_reg;
work.d_inv[298] = 1/work.d[298];
work.L[698] = (work.KKT[597])*work.d_inv[298];
work.v[299] = work.KKT[598];
work.d[299] = work.v[299];
if (work.d[299] < 0)
work.d[299] = settings.kkt_reg;
else
work.d[299] += settings.kkt_reg;
work.d_inv[299] = 1/work.d[299];
work.L[700] = (work.KKT[599])*work.d_inv[299];
work.v[300] = work.KKT[600];
work.d[300] = work.v[300];
if (work.d[300] < 0)
work.d[300] = settings.kkt_reg;
else
work.d[300] += settings.kkt_reg;
work.d_inv[300] = 1/work.d[300];
work.L[703] = (work.KKT[601])*work.d_inv[300];
work.v[301] = work.KKT[602];
work.d[301] = work.v[301];
if (work.d[301] < 0)
work.d[301] = settings.kkt_reg;
else
work.d[301] += settings.kkt_reg;
work.d_inv[301] = 1/work.d[301];
work.L[705] = (work.KKT[603])*work.d_inv[301];
work.v[302] = work.KKT[604];
work.d[302] = work.v[302];
if (work.d[302] < 0)
work.d[302] = settings.kkt_reg;
else
work.d[302] += settings.kkt_reg;
work.d_inv[302] = 1/work.d[302];
work.L[707] = (work.KKT[605])*work.d_inv[302];
work.v[303] = work.KKT[606];
work.d[303] = work.v[303];
if (work.d[303] < 0)
work.d[303] = settings.kkt_reg;
else
work.d[303] += settings.kkt_reg;
work.d_inv[303] = 1/work.d[303];
work.L[710] = (work.KKT[607])*work.d_inv[303];
work.v[304] = work.KKT[608];
work.d[304] = work.v[304];
if (work.d[304] < 0)
work.d[304] = settings.kkt_reg;
else
work.d[304] += settings.kkt_reg;
work.d_inv[304] = 1/work.d[304];
work.L[712] = (work.KKT[609])*work.d_inv[304];
work.v[305] = work.KKT[610];
work.d[305] = work.v[305];
if (work.d[305] < 0)
work.d[305] = settings.kkt_reg;
else
work.d[305] += settings.kkt_reg;
work.d_inv[305] = 1/work.d[305];
work.L[714] = (work.KKT[611])*work.d_inv[305];
work.v[306] = work.KKT[612];
work.d[306] = work.v[306];
if (work.d[306] < 0)
work.d[306] = settings.kkt_reg;
else
work.d[306] += settings.kkt_reg;
work.d_inv[306] = 1/work.d[306];
work.L[717] = (work.KKT[613])*work.d_inv[306];
work.v[307] = work.KKT[614];
work.d[307] = work.v[307];
if (work.d[307] < 0)
work.d[307] = settings.kkt_reg;
else
work.d[307] += settings.kkt_reg;
work.d_inv[307] = 1/work.d[307];
work.L[719] = (work.KKT[615])*work.d_inv[307];
work.v[308] = work.KKT[616];
work.d[308] = work.v[308];
if (work.d[308] < 0)
work.d[308] = settings.kkt_reg;
else
work.d[308] += settings.kkt_reg;
work.d_inv[308] = 1/work.d[308];
work.L[721] = (work.KKT[617])*work.d_inv[308];
work.v[309] = work.KKT[618];
work.d[309] = work.v[309];
if (work.d[309] < 0)
work.d[309] = settings.kkt_reg;
else
work.d[309] += settings.kkt_reg;
work.d_inv[309] = 1/work.d[309];
work.L[724] = (work.KKT[619])*work.d_inv[309];
work.v[310] = work.KKT[620];
work.d[310] = work.v[310];
if (work.d[310] < 0)
work.d[310] = settings.kkt_reg;
else
work.d[310] += settings.kkt_reg;
work.d_inv[310] = 1/work.d[310];
work.L[726] = (work.KKT[621])*work.d_inv[310];
work.v[311] = work.KKT[622];
work.d[311] = work.v[311];
if (work.d[311] < 0)
work.d[311] = settings.kkt_reg;
else
work.d[311] += settings.kkt_reg;
work.d_inv[311] = 1/work.d[311];
work.L[728] = (work.KKT[623])*work.d_inv[311];
work.v[312] = 0;
work.d[312] = work.v[312];
if (work.d[312] > 0)
work.d[312] = -settings.kkt_reg;
else
work.d[312] -= settings.kkt_reg;
work.d_inv[312] = 1/work.d[312];
work.L[0] = (work.KKT[624])*work.d_inv[312];
work.v[313] = 0;
work.d[313] = work.v[313];
if (work.d[313] > 0)
work.d[313] = -settings.kkt_reg;
else
work.d[313] -= settings.kkt_reg;
work.d_inv[313] = 1/work.d[313];
work.L[749] = (work.KKT[625])*work.d_inv[313];
work.v[312] = work.L[0]*work.d[312];
work.v[314] = work.KKT[626]-work.L[0]*work.v[312];
work.d[314] = work.v[314];
if (work.d[314] < 0)
work.d[314] = settings.kkt_reg;
else
work.d[314] += settings.kkt_reg;
work.d_inv[314] = 1/work.d[314];
work.L[744] = (work.KKT[627])*work.d_inv[314];
work.v[315] = work.KKT[628];
work.d[315] = work.v[315];
if (work.d[315] < 0)
work.d[315] = settings.kkt_reg;
else
work.d[315] += settings.kkt_reg;
work.d_inv[315] = 1/work.d[315];
work.L[745] = (work.KKT[629])*work.d_inv[315];
work.v[0] = work.L[1]*work.d[0];
work.v[316] = work.KKT[630]-work.L[1]*work.v[0];
work.d[316] = work.v[316];
if (work.d[316] > 0)
work.d[316] = -settings.kkt_reg;
else
work.d[316] -= settings.kkt_reg;
work.d_inv[316] = 1/work.d[316];
work.L[2] = (work.KKT[631])*work.d_inv[316];
work.v[316] = work.L[2]*work.d[316];
work.v[317] = 0-work.L[2]*work.v[316];
work.d[317] = work.v[317];
if (work.d[317] < 0)
work.d[317] = settings.kkt_reg;
else
work.d[317] += settings.kkt_reg;
work.d_inv[317] = 1/work.d[317];
work.L[4] = (work.KKT[632])*work.d_inv[317];
work.L[6] = (work.KKT[633])*work.d_inv[317];
work.v[1] = work.L[3]*work.d[1];
work.v[317] = work.L[4]*work.d[317];
work.v[318] = work.KKT[634]-work.L[3]*work.v[1]-work.L[4]*work.v[317];
work.d[318] = work.v[318];
if (work.d[318] > 0)
work.d[318] = -settings.kkt_reg;
else
work.d[318] -= settings.kkt_reg;
work.d_inv[318] = 1/work.d[318];
work.L[7] = (-work.L[6]*work.v[317])*work.d_inv[318];
work.L[737] = (work.KKT[635])*work.d_inv[318];
work.v[2] = work.L[5]*work.d[2];
work.v[317] = work.L[6]*work.d[317];
work.v[318] = work.L[7]*work.d[318];
work.v[319] = work.KKT[636]-work.L[5]*work.v[2]-work.L[6]*work.v[317]-work.L[7]*work.v[318];
work.d[319] = work.v[319];
if (work.d[319] > 0)
work.d[319] = -settings.kkt_reg;
else
work.d[319] -= settings.kkt_reg;
work.d_inv[319] = 1/work.d[319];
work.L[738] = (work.KKT[637]-work.L[737]*work.v[318])*work.d_inv[319];
work.v[3] = work.L[8]*work.d[3];
work.v[320] = work.KKT[638]-work.L[8]*work.v[3];
work.d[320] = work.v[320];
if (work.d[320] > 0)
work.d[320] = -settings.kkt_reg;
else
work.d[320] -= settings.kkt_reg;
work.d_inv[320] = 1/work.d[320];
work.L[9] = (work.KKT[639])*work.d_inv[320];
work.v[320] = work.L[9]*work.d[320];
work.v[321] = 0-work.L[9]*work.v[320];
work.d[321] = work.v[321];
if (work.d[321] < 0)
work.d[321] = settings.kkt_reg;
else
work.d[321] += settings.kkt_reg;
work.d_inv[321] = 1/work.d[321];
work.L[11] = (work.KKT[640])*work.d_inv[321];
work.L[13] = (work.KKT[641])*work.d_inv[321];
work.v[4] = work.L[10]*work.d[4];
work.v[321] = work.L[11]*work.d[321];
work.v[322] = work.KKT[642]-work.L[10]*work.v[4]-work.L[11]*work.v[321];
work.d[322] = work.v[322];
if (work.d[322] > 0)
work.d[322] = -settings.kkt_reg;
else
work.d[322] -= settings.kkt_reg;
work.d_inv[322] = 1/work.d[322];
work.L[14] = (-work.L[13]*work.v[321])*work.d_inv[322];
work.L[758] = (work.KKT[643])*work.d_inv[322];
work.v[5] = work.L[12]*work.d[5];
work.v[321] = work.L[13]*work.d[321];
work.v[322] = work.L[14]*work.d[322];
work.v[323] = work.KKT[644]-work.L[12]*work.v[5]-work.L[13]*work.v[321]-work.L[14]*work.v[322];
work.d[323] = work.v[323];
if (work.d[323] > 0)
work.d[323] = -settings.kkt_reg;
else
work.d[323] -= settings.kkt_reg;
work.d_inv[323] = 1/work.d[323];
work.L[759] = (work.KKT[645]-work.L[758]*work.v[322])*work.d_inv[323];
work.v[6] = work.L[15]*work.d[6];
work.v[324] = work.KKT[646]-work.L[15]*work.v[6];
work.d[324] = work.v[324];
if (work.d[324] > 0)
work.d[324] = -settings.kkt_reg;
else
work.d[324] -= settings.kkt_reg;
work.d_inv[324] = 1/work.d[324];
work.L[16] = (work.KKT[647])*work.d_inv[324];
work.v[324] = work.L[16]*work.d[324];
work.v[325] = 0-work.L[16]*work.v[324];
work.d[325] = work.v[325];
if (work.d[325] < 0)
work.d[325] = settings.kkt_reg;
else
work.d[325] += settings.kkt_reg;
work.d_inv[325] = 1/work.d[325];
work.L[18] = (work.KKT[648])*work.d_inv[325];
work.L[20] = (work.KKT[649])*work.d_inv[325];
work.v[7] = work.L[17]*work.d[7];
work.v[325] = work.L[18]*work.d[325];
work.v[326] = work.KKT[650]-work.L[17]*work.v[7]-work.L[18]*work.v[325];
work.d[326] = work.v[326];
if (work.d[326] > 0)
work.d[326] = -settings.kkt_reg;
else
work.d[326] -= settings.kkt_reg;
work.d_inv[326] = 1/work.d[326];
work.L[21] = (-work.L[20]*work.v[325])*work.d_inv[326];
work.L[820] = (work.KKT[651])*work.d_inv[326];
work.v[8] = work.L[19]*work.d[8];
work.v[325] = work.L[20]*work.d[325];
work.v[326] = work.L[21]*work.d[326];
work.v[327] = work.KKT[652]-work.L[19]*work.v[8]-work.L[20]*work.v[325]-work.L[21]*work.v[326];
work.d[327] = work.v[327];
if (work.d[327] > 0)
work.d[327] = -settings.kkt_reg;
else
work.d[327] -= settings.kkt_reg;
work.d_inv[327] = 1/work.d[327];
work.L[821] = (work.KKT[653]-work.L[820]*work.v[326])*work.d_inv[327];
work.v[9] = work.L[22]*work.d[9];
work.v[328] = work.KKT[654]-work.L[22]*work.v[9];
work.d[328] = work.v[328];
if (work.d[328] > 0)
work.d[328] = -settings.kkt_reg;
else
work.d[328] -= settings.kkt_reg;
work.d_inv[328] = 1/work.d[328];
work.L[23] = (work.KKT[655])*work.d_inv[328];
work.v[328] = work.L[23]*work.d[328];
work.v[329] = 0-work.L[23]*work.v[328];
work.d[329] = work.v[329];
if (work.d[329] < 0)
work.d[329] = settings.kkt_reg;
else
work.d[329] += settings.kkt_reg;
work.d_inv[329] = 1/work.d[329];
work.L[25] = (work.KKT[656])*work.d_inv[329];
work.L[27] = (work.KKT[657])*work.d_inv[329];
work.v[10] = work.L[24]*work.d[10];
work.v[329] = work.L[25]*work.d[329];
work.v[330] = work.KKT[658]-work.L[24]*work.v[10]-work.L[25]*work.v[329];
work.d[330] = work.v[330];
if (work.d[330] > 0)
work.d[330] = -settings.kkt_reg;
else
work.d[330] -= settings.kkt_reg;
work.d_inv[330] = 1/work.d[330];
work.L[28] = (-work.L[27]*work.v[329])*work.d_inv[330];
work.L[857] = (work.KKT[659])*work.d_inv[330];
work.v[11] = work.L[26]*work.d[11];
work.v[329] = work.L[27]*work.d[329];
work.v[330] = work.L[28]*work.d[330];
work.v[331] = work.KKT[660]-work.L[26]*work.v[11]-work.L[27]*work.v[329]-work.L[28]*work.v[330];
work.d[331] = work.v[331];
if (work.d[331] > 0)
work.d[331] = -settings.kkt_reg;
else
work.d[331] -= settings.kkt_reg;
work.d_inv[331] = 1/work.d[331];
work.L[858] = (work.KKT[661]-work.L[857]*work.v[330])*work.d_inv[331];
work.v[12] = work.L[29]*work.d[12];
work.v[332] = work.KKT[662]-work.L[29]*work.v[12];
work.d[332] = work.v[332];
if (work.d[332] > 0)
work.d[332] = -settings.kkt_reg;
else
work.d[332] -= settings.kkt_reg;
work.d_inv[332] = 1/work.d[332];
work.L[30] = (work.KKT[663])*work.d_inv[332];
work.v[332] = work.L[30]*work.d[332];
work.v[333] = 0-work.L[30]*work.v[332];
work.d[333] = work.v[333];
if (work.d[333] < 0)
work.d[333] = settings.kkt_reg;
else
work.d[333] += settings.kkt_reg;
work.d_inv[333] = 1/work.d[333];
work.L[32] = (work.KKT[664])*work.d_inv[333];
work.L[34] = (work.KKT[665])*work.d_inv[333];
work.v[13] = work.L[31]*work.d[13];
work.v[333] = work.L[32]*work.d[333];
work.v[334] = work.KKT[666]-work.L[31]*work.v[13]-work.L[32]*work.v[333];
work.d[334] = work.v[334];
if (work.d[334] > 0)
work.d[334] = -settings.kkt_reg;
else
work.d[334] -= settings.kkt_reg;
work.d_inv[334] = 1/work.d[334];
work.L[35] = (-work.L[34]*work.v[333])*work.d_inv[334];
work.L[891] = (work.KKT[667])*work.d_inv[334];
work.v[14] = work.L[33]*work.d[14];
work.v[333] = work.L[34]*work.d[333];
work.v[334] = work.L[35]*work.d[334];
work.v[335] = work.KKT[668]-work.L[33]*work.v[14]-work.L[34]*work.v[333]-work.L[35]*work.v[334];
work.d[335] = work.v[335];
if (work.d[335] > 0)
work.d[335] = -settings.kkt_reg;
else
work.d[335] -= settings.kkt_reg;
work.d_inv[335] = 1/work.d[335];
work.L[892] = (work.KKT[669]-work.L[891]*work.v[334])*work.d_inv[335];
work.v[15] = work.L[36]*work.d[15];
work.v[336] = work.KKT[670]-work.L[36]*work.v[15];
work.d[336] = work.v[336];
if (work.d[336] > 0)
work.d[336] = -settings.kkt_reg;
else
work.d[336] -= settings.kkt_reg;
work.d_inv[336] = 1/work.d[336];
work.L[37] = (work.KKT[671])*work.d_inv[336];
work.v[336] = work.L[37]*work.d[336];
work.v[337] = 0-work.L[37]*work.v[336];
work.d[337] = work.v[337];
if (work.d[337] < 0)
work.d[337] = settings.kkt_reg;
else
work.d[337] += settings.kkt_reg;
work.d_inv[337] = 1/work.d[337];
work.L[39] = (work.KKT[672])*work.d_inv[337];
work.L[41] = (work.KKT[673])*work.d_inv[337];
work.v[16] = work.L[38]*work.d[16];
work.v[337] = work.L[39]*work.d[337];
work.v[338] = work.KKT[674]-work.L[38]*work.v[16]-work.L[39]*work.v[337];
work.d[338] = work.v[338];
if (work.d[338] > 0)
work.d[338] = -settings.kkt_reg;
else
work.d[338] -= settings.kkt_reg;
work.d_inv[338] = 1/work.d[338];
work.L[42] = (-work.L[41]*work.v[337])*work.d_inv[338];
work.L[925] = (work.KKT[675])*work.d_inv[338];
work.v[17] = work.L[40]*work.d[17];
work.v[337] = work.L[41]*work.d[337];
work.v[338] = work.L[42]*work.d[338];
work.v[339] = work.KKT[676]-work.L[40]*work.v[17]-work.L[41]*work.v[337]-work.L[42]*work.v[338];
work.d[339] = work.v[339];
if (work.d[339] > 0)
work.d[339] = -settings.kkt_reg;
else
work.d[339] -= settings.kkt_reg;
work.d_inv[339] = 1/work.d[339];
work.L[926] = (work.KKT[677]-work.L[925]*work.v[338])*work.d_inv[339];
work.v[18] = work.L[43]*work.d[18];
work.v[340] = work.KKT[678]-work.L[43]*work.v[18];
work.d[340] = work.v[340];
if (work.d[340] > 0)
work.d[340] = -settings.kkt_reg;
else
work.d[340] -= settings.kkt_reg;
work.d_inv[340] = 1/work.d[340];
work.L[44] = (work.KKT[679])*work.d_inv[340];
work.v[340] = work.L[44]*work.d[340];
work.v[341] = 0-work.L[44]*work.v[340];
work.d[341] = work.v[341];
if (work.d[341] < 0)
work.d[341] = settings.kkt_reg;
else
work.d[341] += settings.kkt_reg;
work.d_inv[341] = 1/work.d[341];
work.L[46] = (work.KKT[680])*work.d_inv[341];
work.L[48] = (work.KKT[681])*work.d_inv[341];
work.v[19] = work.L[45]*work.d[19];
work.v[341] = work.L[46]*work.d[341];
work.v[342] = work.KKT[682]-work.L[45]*work.v[19]-work.L[46]*work.v[341];
work.d[342] = work.v[342];
if (work.d[342] > 0)
work.d[342] = -settings.kkt_reg;
else
work.d[342] -= settings.kkt_reg;
work.d_inv[342] = 1/work.d[342];
work.L[49] = (-work.L[48]*work.v[341])*work.d_inv[342];
work.L[959] = (work.KKT[683])*work.d_inv[342];
work.v[20] = work.L[47]*work.d[20];
work.v[341] = work.L[48]*work.d[341];
work.v[342] = work.L[49]*work.d[342];
work.v[343] = work.KKT[684]-work.L[47]*work.v[20]-work.L[48]*work.v[341]-work.L[49]*work.v[342];
work.d[343] = work.v[343];
if (work.d[343] > 0)
work.d[343] = -settings.kkt_reg;
else
work.d[343] -= settings.kkt_reg;
work.d_inv[343] = 1/work.d[343];
work.L[960] = (work.KKT[685]-work.L[959]*work.v[342])*work.d_inv[343];
work.v[21] = work.L[50]*work.d[21];
work.v[344] = work.KKT[686]-work.L[50]*work.v[21];
work.d[344] = work.v[344];
if (work.d[344] > 0)
work.d[344] = -settings.kkt_reg;
else
work.d[344] -= settings.kkt_reg;
work.d_inv[344] = 1/work.d[344];
work.L[51] = (work.KKT[687])*work.d_inv[344];
work.v[344] = work.L[51]*work.d[344];
work.v[345] = 0-work.L[51]*work.v[344];
work.d[345] = work.v[345];
if (work.d[345] < 0)
work.d[345] = settings.kkt_reg;
else
work.d[345] += settings.kkt_reg;
work.d_inv[345] = 1/work.d[345];
work.L[53] = (work.KKT[688])*work.d_inv[345];
work.L[55] = (work.KKT[689])*work.d_inv[345];
work.v[22] = work.L[52]*work.d[22];
work.v[345] = work.L[53]*work.d[345];
work.v[346] = work.KKT[690]-work.L[52]*work.v[22]-work.L[53]*work.v[345];
work.d[346] = work.v[346];
if (work.d[346] > 0)
work.d[346] = -settings.kkt_reg;
else
work.d[346] -= settings.kkt_reg;
work.d_inv[346] = 1/work.d[346];
work.L[56] = (-work.L[55]*work.v[345])*work.d_inv[346];
work.L[993] = (work.KKT[691])*work.d_inv[346];
work.v[23] = work.L[54]*work.d[23];
work.v[345] = work.L[55]*work.d[345];
work.v[346] = work.L[56]*work.d[346];
work.v[347] = work.KKT[692]-work.L[54]*work.v[23]-work.L[55]*work.v[345]-work.L[56]*work.v[346];
work.d[347] = work.v[347];
if (work.d[347] > 0)
work.d[347] = -settings.kkt_reg;
else
work.d[347] -= settings.kkt_reg;
work.d_inv[347] = 1/work.d[347];
work.L[994] = (work.KKT[693]-work.L[993]*work.v[346])*work.d_inv[347];
work.v[24] = work.L[57]*work.d[24];
work.v[348] = work.KKT[694]-work.L[57]*work.v[24];
work.d[348] = work.v[348];
if (work.d[348] > 0)
work.d[348] = -settings.kkt_reg;
else
work.d[348] -= settings.kkt_reg;
work.d_inv[348] = 1/work.d[348];
work.L[58] = (work.KKT[695])*work.d_inv[348];
work.v[348] = work.L[58]*work.d[348];
work.v[349] = 0-work.L[58]*work.v[348];
work.d[349] = work.v[349];
if (work.d[349] < 0)
work.d[349] = settings.kkt_reg;
else
work.d[349] += settings.kkt_reg;
work.d_inv[349] = 1/work.d[349];
work.L[60] = (work.KKT[696])*work.d_inv[349];
work.L[62] = (work.KKT[697])*work.d_inv[349];
work.v[25] = work.L[59]*work.d[25];
work.v[349] = work.L[60]*work.d[349];
work.v[350] = work.KKT[698]-work.L[59]*work.v[25]-work.L[60]*work.v[349];
work.d[350] = work.v[350];
if (work.d[350] > 0)
work.d[350] = -settings.kkt_reg;
else
work.d[350] -= settings.kkt_reg;
work.d_inv[350] = 1/work.d[350];
work.L[63] = (-work.L[62]*work.v[349])*work.d_inv[350];
work.L[1027] = (work.KKT[699])*work.d_inv[350];
work.v[26] = work.L[61]*work.d[26];
work.v[349] = work.L[62]*work.d[349];
work.v[350] = work.L[63]*work.d[350];
work.v[351] = work.KKT[700]-work.L[61]*work.v[26]-work.L[62]*work.v[349]-work.L[63]*work.v[350];
work.d[351] = work.v[351];
if (work.d[351] > 0)
work.d[351] = -settings.kkt_reg;
else
work.d[351] -= settings.kkt_reg;
work.d_inv[351] = 1/work.d[351];
work.L[1028] = (work.KKT[701]-work.L[1027]*work.v[350])*work.d_inv[351];
work.v[27] = work.L[64]*work.d[27];
work.v[352] = work.KKT[702]-work.L[64]*work.v[27];
work.d[352] = work.v[352];
if (work.d[352] > 0)
work.d[352] = -settings.kkt_reg;
else
work.d[352] -= settings.kkt_reg;
work.d_inv[352] = 1/work.d[352];
work.L[65] = (work.KKT[703])*work.d_inv[352];
work.v[352] = work.L[65]*work.d[352];
work.v[353] = 0-work.L[65]*work.v[352];
work.d[353] = work.v[353];
if (work.d[353] < 0)
work.d[353] = settings.kkt_reg;
else
work.d[353] += settings.kkt_reg;
work.d_inv[353] = 1/work.d[353];
work.L[67] = (work.KKT[704])*work.d_inv[353];
work.L[69] = (work.KKT[705])*work.d_inv[353];
work.v[28] = work.L[66]*work.d[28];
work.v[353] = work.L[67]*work.d[353];
work.v[354] = work.KKT[706]-work.L[66]*work.v[28]-work.L[67]*work.v[353];
work.d[354] = work.v[354];
if (work.d[354] > 0)
work.d[354] = -settings.kkt_reg;
else
work.d[354] -= settings.kkt_reg;
work.d_inv[354] = 1/work.d[354];
work.L[70] = (-work.L[69]*work.v[353])*work.d_inv[354];
work.L[1061] = (work.KKT[707])*work.d_inv[354];
work.v[29] = work.L[68]*work.d[29];
work.v[353] = work.L[69]*work.d[353];
work.v[354] = work.L[70]*work.d[354];
work.v[355] = work.KKT[708]-work.L[68]*work.v[29]-work.L[69]*work.v[353]-work.L[70]*work.v[354];
work.d[355] = work.v[355];
if (work.d[355] > 0)
work.d[355] = -settings.kkt_reg;
else
work.d[355] -= settings.kkt_reg;
work.d_inv[355] = 1/work.d[355];
work.L[1062] = (work.KKT[709]-work.L[1061]*work.v[354])*work.d_inv[355];
work.v[30] = work.L[71]*work.d[30];
work.v[356] = work.KKT[710]-work.L[71]*work.v[30];
work.d[356] = work.v[356];
if (work.d[356] > 0)
work.d[356] = -settings.kkt_reg;
else
work.d[356] -= settings.kkt_reg;
work.d_inv[356] = 1/work.d[356];
work.L[72] = (work.KKT[711])*work.d_inv[356];
work.v[356] = work.L[72]*work.d[356];
work.v[357] = 0-work.L[72]*work.v[356];
work.d[357] = work.v[357];
if (work.d[357] < 0)
work.d[357] = settings.kkt_reg;
else
work.d[357] += settings.kkt_reg;
work.d_inv[357] = 1/work.d[357];
work.L[74] = (work.KKT[712])*work.d_inv[357];
work.L[76] = (work.KKT[713])*work.d_inv[357];
work.v[31] = work.L[73]*work.d[31];
work.v[357] = work.L[74]*work.d[357];
work.v[358] = work.KKT[714]-work.L[73]*work.v[31]-work.L[74]*work.v[357];
work.d[358] = work.v[358];
if (work.d[358] > 0)
work.d[358] = -settings.kkt_reg;
else
work.d[358] -= settings.kkt_reg;
work.d_inv[358] = 1/work.d[358];
work.L[77] = (-work.L[76]*work.v[357])*work.d_inv[358];
work.L[1095] = (work.KKT[715])*work.d_inv[358];
work.v[32] = work.L[75]*work.d[32];
work.v[357] = work.L[76]*work.d[357];
work.v[358] = work.L[77]*work.d[358];
work.v[359] = work.KKT[716]-work.L[75]*work.v[32]-work.L[76]*work.v[357]-work.L[77]*work.v[358];
work.d[359] = work.v[359];
if (work.d[359] > 0)
work.d[359] = -settings.kkt_reg;
else
work.d[359] -= settings.kkt_reg;
work.d_inv[359] = 1/work.d[359];
work.L[1096] = (work.KKT[717]-work.L[1095]*work.v[358])*work.d_inv[359];
work.v[33] = work.L[78]*work.d[33];
work.v[360] = work.KKT[718]-work.L[78]*work.v[33];
work.d[360] = work.v[360];
if (work.d[360] > 0)
work.d[360] = -settings.kkt_reg;
else
work.d[360] -= settings.kkt_reg;
work.d_inv[360] = 1/work.d[360];
work.L[79] = (work.KKT[719])*work.d_inv[360];
work.v[360] = work.L[79]*work.d[360];
work.v[361] = 0-work.L[79]*work.v[360];
work.d[361] = work.v[361];
if (work.d[361] < 0)
work.d[361] = settings.kkt_reg;
else
work.d[361] += settings.kkt_reg;
work.d_inv[361] = 1/work.d[361];
work.L[81] = (work.KKT[720])*work.d_inv[361];
work.L[83] = (work.KKT[721])*work.d_inv[361];
work.v[34] = work.L[80]*work.d[34];
work.v[361] = work.L[81]*work.d[361];
work.v[362] = work.KKT[722]-work.L[80]*work.v[34]-work.L[81]*work.v[361];
work.d[362] = work.v[362];
if (work.d[362] > 0)
work.d[362] = -settings.kkt_reg;
else
work.d[362] -= settings.kkt_reg;
work.d_inv[362] = 1/work.d[362];
work.L[84] = (-work.L[83]*work.v[361])*work.d_inv[362];
work.L[1129] = (work.KKT[723])*work.d_inv[362];
work.v[35] = work.L[82]*work.d[35];
work.v[361] = work.L[83]*work.d[361];
work.v[362] = work.L[84]*work.d[362];
work.v[363] = work.KKT[724]-work.L[82]*work.v[35]-work.L[83]*work.v[361]-work.L[84]*work.v[362];
work.d[363] = work.v[363];
if (work.d[363] > 0)
work.d[363] = -settings.kkt_reg;
else
work.d[363] -= settings.kkt_reg;
work.d_inv[363] = 1/work.d[363];
work.L[1130] = (work.KKT[725]-work.L[1129]*work.v[362])*work.d_inv[363];
work.v[36] = work.L[85]*work.d[36];
work.v[364] = work.KKT[726]-work.L[85]*work.v[36];
work.d[364] = work.v[364];
if (work.d[364] > 0)
work.d[364] = -settings.kkt_reg;
else
work.d[364] -= settings.kkt_reg;
work.d_inv[364] = 1/work.d[364];
work.L[86] = (work.KKT[727])*work.d_inv[364];
work.v[364] = work.L[86]*work.d[364];
work.v[365] = 0-work.L[86]*work.v[364];
work.d[365] = work.v[365];
if (work.d[365] < 0)
work.d[365] = settings.kkt_reg;
else
work.d[365] += settings.kkt_reg;
work.d_inv[365] = 1/work.d[365];
work.L[88] = (work.KKT[728])*work.d_inv[365];
work.L[90] = (work.KKT[729])*work.d_inv[365];
work.v[37] = work.L[87]*work.d[37];
work.v[365] = work.L[88]*work.d[365];
work.v[366] = work.KKT[730]-work.L[87]*work.v[37]-work.L[88]*work.v[365];
work.d[366] = work.v[366];
if (work.d[366] > 0)
work.d[366] = -settings.kkt_reg;
else
work.d[366] -= settings.kkt_reg;
work.d_inv[366] = 1/work.d[366];
work.L[91] = (-work.L[90]*work.v[365])*work.d_inv[366];
work.L[1163] = (work.KKT[731])*work.d_inv[366];
work.v[38] = work.L[89]*work.d[38];
work.v[365] = work.L[90]*work.d[365];
work.v[366] = work.L[91]*work.d[366];
work.v[367] = work.KKT[732]-work.L[89]*work.v[38]-work.L[90]*work.v[365]-work.L[91]*work.v[366];
work.d[367] = work.v[367];
if (work.d[367] > 0)
work.d[367] = -settings.kkt_reg;
else
work.d[367] -= settings.kkt_reg;
work.d_inv[367] = 1/work.d[367];
work.L[1164] = (work.KKT[733]-work.L[1163]*work.v[366])*work.d_inv[367];
work.v[39] = work.L[92]*work.d[39];
work.v[368] = work.KKT[734]-work.L[92]*work.v[39];
work.d[368] = work.v[368];
if (work.d[368] > 0)
work.d[368] = -settings.kkt_reg;
else
work.d[368] -= settings.kkt_reg;
work.d_inv[368] = 1/work.d[368];
work.L[93] = (work.KKT[735])*work.d_inv[368];
work.v[368] = work.L[93]*work.d[368];
work.v[369] = 0-work.L[93]*work.v[368];
work.d[369] = work.v[369];
if (work.d[369] < 0)
work.d[369] = settings.kkt_reg;
else
work.d[369] += settings.kkt_reg;
work.d_inv[369] = 1/work.d[369];
work.L[95] = (work.KKT[736])*work.d_inv[369];
work.L[97] = (work.KKT[737])*work.d_inv[369];
work.v[40] = work.L[94]*work.d[40];
work.v[369] = work.L[95]*work.d[369];
work.v[370] = work.KKT[738]-work.L[94]*work.v[40]-work.L[95]*work.v[369];
work.d[370] = work.v[370];
if (work.d[370] > 0)
work.d[370] = -settings.kkt_reg;
else
work.d[370] -= settings.kkt_reg;
work.d_inv[370] = 1/work.d[370];
work.L[98] = (-work.L[97]*work.v[369])*work.d_inv[370];
work.L[1197] = (work.KKT[739])*work.d_inv[370];
work.v[41] = work.L[96]*work.d[41];
work.v[369] = work.L[97]*work.d[369];
work.v[370] = work.L[98]*work.d[370];
work.v[371] = work.KKT[740]-work.L[96]*work.v[41]-work.L[97]*work.v[369]-work.L[98]*work.v[370];
work.d[371] = work.v[371];
if (work.d[371] > 0)
work.d[371] = -settings.kkt_reg;
else
work.d[371] -= settings.kkt_reg;
work.d_inv[371] = 1/work.d[371];
work.L[1198] = (work.KKT[741]-work.L[1197]*work.v[370])*work.d_inv[371];
work.v[42] = work.L[99]*work.d[42];
work.v[372] = work.KKT[742]-work.L[99]*work.v[42];
work.d[372] = work.v[372];
if (work.d[372] > 0)
work.d[372] = -settings.kkt_reg;
else
work.d[372] -= settings.kkt_reg;
work.d_inv[372] = 1/work.d[372];
work.L[100] = (work.KKT[743])*work.d_inv[372];
work.v[372] = work.L[100]*work.d[372];
work.v[373] = 0-work.L[100]*work.v[372];
work.d[373] = work.v[373];
if (work.d[373] < 0)
work.d[373] = settings.kkt_reg;
else
work.d[373] += settings.kkt_reg;
work.d_inv[373] = 1/work.d[373];
work.L[102] = (work.KKT[744])*work.d_inv[373];
work.L[104] = (work.KKT[745])*work.d_inv[373];
work.v[43] = work.L[101]*work.d[43];
work.v[373] = work.L[102]*work.d[373];
work.v[374] = work.KKT[746]-work.L[101]*work.v[43]-work.L[102]*work.v[373];
work.d[374] = work.v[374];
if (work.d[374] > 0)
work.d[374] = -settings.kkt_reg;
else
work.d[374] -= settings.kkt_reg;
work.d_inv[374] = 1/work.d[374];
work.L[105] = (-work.L[104]*work.v[373])*work.d_inv[374];
work.L[1231] = (work.KKT[747])*work.d_inv[374];
work.v[44] = work.L[103]*work.d[44];
work.v[373] = work.L[104]*work.d[373];
work.v[374] = work.L[105]*work.d[374];
work.v[375] = work.KKT[748]-work.L[103]*work.v[44]-work.L[104]*work.v[373]-work.L[105]*work.v[374];
work.d[375] = work.v[375];
if (work.d[375] > 0)
work.d[375] = -settings.kkt_reg;
else
work.d[375] -= settings.kkt_reg;
work.d_inv[375] = 1/work.d[375];
work.L[1232] = (work.KKT[749]-work.L[1231]*work.v[374])*work.d_inv[375];
work.v[45] = work.L[106]*work.d[45];
work.v[376] = work.KKT[750]-work.L[106]*work.v[45];
work.d[376] = work.v[376];
if (work.d[376] > 0)
work.d[376] = -settings.kkt_reg;
else
work.d[376] -= settings.kkt_reg;
work.d_inv[376] = 1/work.d[376];
work.L[107] = (work.KKT[751])*work.d_inv[376];
work.v[376] = work.L[107]*work.d[376];
work.v[377] = 0-work.L[107]*work.v[376];
work.d[377] = work.v[377];
if (work.d[377] < 0)
work.d[377] = settings.kkt_reg;
else
work.d[377] += settings.kkt_reg;
work.d_inv[377] = 1/work.d[377];
work.L[109] = (work.KKT[752])*work.d_inv[377];
work.L[111] = (work.KKT[753])*work.d_inv[377];
work.v[46] = work.L[108]*work.d[46];
work.v[377] = work.L[109]*work.d[377];
work.v[378] = work.KKT[754]-work.L[108]*work.v[46]-work.L[109]*work.v[377];
work.d[378] = work.v[378];
if (work.d[378] > 0)
work.d[378] = -settings.kkt_reg;
else
work.d[378] -= settings.kkt_reg;
work.d_inv[378] = 1/work.d[378];
work.L[112] = (-work.L[111]*work.v[377])*work.d_inv[378];
work.L[1265] = (work.KKT[755])*work.d_inv[378];
work.v[47] = work.L[110]*work.d[47];
work.v[377] = work.L[111]*work.d[377];
work.v[378] = work.L[112]*work.d[378];
work.v[379] = work.KKT[756]-work.L[110]*work.v[47]-work.L[111]*work.v[377]-work.L[112]*work.v[378];
work.d[379] = work.v[379];
if (work.d[379] > 0)
work.d[379] = -settings.kkt_reg;
else
work.d[379] -= settings.kkt_reg;
work.d_inv[379] = 1/work.d[379];
work.L[1266] = (work.KKT[757]-work.L[1265]*work.v[378])*work.d_inv[379];
work.v[48] = work.L[113]*work.d[48];
work.v[380] = work.KKT[758]-work.L[113]*work.v[48];
work.d[380] = work.v[380];
if (work.d[380] > 0)
work.d[380] = -settings.kkt_reg;
else
work.d[380] -= settings.kkt_reg;
work.d_inv[380] = 1/work.d[380];
work.L[114] = (work.KKT[759])*work.d_inv[380];
work.v[380] = work.L[114]*work.d[380];
work.v[381] = 0-work.L[114]*work.v[380];
work.d[381] = work.v[381];
if (work.d[381] < 0)
work.d[381] = settings.kkt_reg;
else
work.d[381] += settings.kkt_reg;
work.d_inv[381] = 1/work.d[381];
work.L[116] = (work.KKT[760])*work.d_inv[381];
work.L[118] = (work.KKT[761])*work.d_inv[381];
work.v[49] = work.L[115]*work.d[49];
work.v[381] = work.L[116]*work.d[381];
work.v[382] = work.KKT[762]-work.L[115]*work.v[49]-work.L[116]*work.v[381];
work.d[382] = work.v[382];
if (work.d[382] > 0)
work.d[382] = -settings.kkt_reg;
else
work.d[382] -= settings.kkt_reg;
work.d_inv[382] = 1/work.d[382];
work.L[119] = (-work.L[118]*work.v[381])*work.d_inv[382];
work.L[1299] = (work.KKT[763])*work.d_inv[382];
work.v[50] = work.L[117]*work.d[50];
work.v[381] = work.L[118]*work.d[381];
work.v[382] = work.L[119]*work.d[382];
work.v[383] = work.KKT[764]-work.L[117]*work.v[50]-work.L[118]*work.v[381]-work.L[119]*work.v[382];
work.d[383] = work.v[383];
if (work.d[383] > 0)
work.d[383] = -settings.kkt_reg;
else
work.d[383] -= settings.kkt_reg;
work.d_inv[383] = 1/work.d[383];
work.L[1300] = (work.KKT[765]-work.L[1299]*work.v[382])*work.d_inv[383];
work.v[51] = work.L[120]*work.d[51];
work.v[384] = work.KKT[766]-work.L[120]*work.v[51];
work.d[384] = work.v[384];
if (work.d[384] > 0)
work.d[384] = -settings.kkt_reg;
else
work.d[384] -= settings.kkt_reg;
work.d_inv[384] = 1/work.d[384];
work.L[121] = (work.KKT[767])*work.d_inv[384];
work.v[384] = work.L[121]*work.d[384];
work.v[385] = 0-work.L[121]*work.v[384];
work.d[385] = work.v[385];
if (work.d[385] < 0)
work.d[385] = settings.kkt_reg;
else
work.d[385] += settings.kkt_reg;
work.d_inv[385] = 1/work.d[385];
work.L[123] = (work.KKT[768])*work.d_inv[385];
work.L[125] = (work.KKT[769])*work.d_inv[385];
work.v[52] = work.L[122]*work.d[52];
work.v[385] = work.L[123]*work.d[385];
work.v[386] = work.KKT[770]-work.L[122]*work.v[52]-work.L[123]*work.v[385];
work.d[386] = work.v[386];
if (work.d[386] > 0)
work.d[386] = -settings.kkt_reg;
else
work.d[386] -= settings.kkt_reg;
work.d_inv[386] = 1/work.d[386];
work.L[126] = (-work.L[125]*work.v[385])*work.d_inv[386];
work.L[1333] = (work.KKT[771])*work.d_inv[386];
work.v[53] = work.L[124]*work.d[53];
work.v[385] = work.L[125]*work.d[385];
work.v[386] = work.L[126]*work.d[386];
work.v[387] = work.KKT[772]-work.L[124]*work.v[53]-work.L[125]*work.v[385]-work.L[126]*work.v[386];
work.d[387] = work.v[387];
if (work.d[387] > 0)
work.d[387] = -settings.kkt_reg;
else
work.d[387] -= settings.kkt_reg;
work.d_inv[387] = 1/work.d[387];
work.L[1334] = (work.KKT[773]-work.L[1333]*work.v[386])*work.d_inv[387];
work.v[54] = work.L[127]*work.d[54];
work.v[388] = work.KKT[774]-work.L[127]*work.v[54];
work.d[388] = work.v[388];
if (work.d[388] > 0)
work.d[388] = -settings.kkt_reg;
else
work.d[388] -= settings.kkt_reg;
work.d_inv[388] = 1/work.d[388];
work.L[128] = (work.KKT[775])*work.d_inv[388];
work.v[388] = work.L[128]*work.d[388];
work.v[389] = 0-work.L[128]*work.v[388];
work.d[389] = work.v[389];
if (work.d[389] < 0)
work.d[389] = settings.kkt_reg;
else
work.d[389] += settings.kkt_reg;
work.d_inv[389] = 1/work.d[389];
work.L[130] = (work.KKT[776])*work.d_inv[389];
work.L[132] = (work.KKT[777])*work.d_inv[389];
work.v[55] = work.L[129]*work.d[55];
work.v[389] = work.L[130]*work.d[389];
work.v[390] = work.KKT[778]-work.L[129]*work.v[55]-work.L[130]*work.v[389];
work.d[390] = work.v[390];
if (work.d[390] > 0)
work.d[390] = -settings.kkt_reg;
else
work.d[390] -= settings.kkt_reg;
work.d_inv[390] = 1/work.d[390];
work.L[133] = (-work.L[132]*work.v[389])*work.d_inv[390];
work.L[1367] = (work.KKT[779])*work.d_inv[390];
work.v[56] = work.L[131]*work.d[56];
work.v[389] = work.L[132]*work.d[389];
work.v[390] = work.L[133]*work.d[390];
work.v[391] = work.KKT[780]-work.L[131]*work.v[56]-work.L[132]*work.v[389]-work.L[133]*work.v[390];
work.d[391] = work.v[391];
if (work.d[391] > 0)
work.d[391] = -settings.kkt_reg;
else
work.d[391] -= settings.kkt_reg;
work.d_inv[391] = 1/work.d[391];
work.L[1368] = (work.KKT[781]-work.L[1367]*work.v[390])*work.d_inv[391];
work.v[57] = work.L[134]*work.d[57];
work.v[392] = work.KKT[782]-work.L[134]*work.v[57];
work.d[392] = work.v[392];
if (work.d[392] > 0)
work.d[392] = -settings.kkt_reg;
else
work.d[392] -= settings.kkt_reg;
work.d_inv[392] = 1/work.d[392];
work.L[135] = (work.KKT[783])*work.d_inv[392];
work.v[392] = work.L[135]*work.d[392];
work.v[393] = 0-work.L[135]*work.v[392];
work.d[393] = work.v[393];
if (work.d[393] < 0)
work.d[393] = settings.kkt_reg;
else
work.d[393] += settings.kkt_reg;
work.d_inv[393] = 1/work.d[393];
work.L[137] = (work.KKT[784])*work.d_inv[393];
work.L[139] = (work.KKT[785])*work.d_inv[393];
work.v[58] = work.L[136]*work.d[58];
work.v[393] = work.L[137]*work.d[393];
work.v[394] = work.KKT[786]-work.L[136]*work.v[58]-work.L[137]*work.v[393];
work.d[394] = work.v[394];
if (work.d[394] > 0)
work.d[394] = -settings.kkt_reg;
else
work.d[394] -= settings.kkt_reg;
work.d_inv[394] = 1/work.d[394];
work.L[140] = (-work.L[139]*work.v[393])*work.d_inv[394];
work.L[1401] = (work.KKT[787])*work.d_inv[394];
work.v[59] = work.L[138]*work.d[59];
work.v[393] = work.L[139]*work.d[393];
work.v[394] = work.L[140]*work.d[394];
work.v[395] = work.KKT[788]-work.L[138]*work.v[59]-work.L[139]*work.v[393]-work.L[140]*work.v[394];
work.d[395] = work.v[395];
if (work.d[395] > 0)
work.d[395] = -settings.kkt_reg;
else
work.d[395] -= settings.kkt_reg;
work.d_inv[395] = 1/work.d[395];
work.L[1402] = (work.KKT[789]-work.L[1401]*work.v[394])*work.d_inv[395];
work.v[60] = work.L[141]*work.d[60];
work.v[396] = work.KKT[790]-work.L[141]*work.v[60];
work.d[396] = work.v[396];
if (work.d[396] > 0)
work.d[396] = -settings.kkt_reg;
else
work.d[396] -= settings.kkt_reg;
work.d_inv[396] = 1/work.d[396];
work.L[142] = (work.KKT[791])*work.d_inv[396];
work.v[396] = work.L[142]*work.d[396];
work.v[397] = 0-work.L[142]*work.v[396];
work.d[397] = work.v[397];
if (work.d[397] < 0)
work.d[397] = settings.kkt_reg;
else
work.d[397] += settings.kkt_reg;
work.d_inv[397] = 1/work.d[397];
work.L[144] = (work.KKT[792])*work.d_inv[397];
work.L[146] = (work.KKT[793])*work.d_inv[397];
work.v[61] = work.L[143]*work.d[61];
work.v[397] = work.L[144]*work.d[397];
work.v[398] = work.KKT[794]-work.L[143]*work.v[61]-work.L[144]*work.v[397];
work.d[398] = work.v[398];
if (work.d[398] > 0)
work.d[398] = -settings.kkt_reg;
else
work.d[398] -= settings.kkt_reg;
work.d_inv[398] = 1/work.d[398];
work.L[147] = (-work.L[146]*work.v[397])*work.d_inv[398];
work.L[1435] = (work.KKT[795])*work.d_inv[398];
work.v[62] = work.L[145]*work.d[62];
work.v[397] = work.L[146]*work.d[397];
work.v[398] = work.L[147]*work.d[398];
work.v[399] = work.KKT[796]-work.L[145]*work.v[62]-work.L[146]*work.v[397]-work.L[147]*work.v[398];
work.d[399] = work.v[399];
if (work.d[399] > 0)
work.d[399] = -settings.kkt_reg;
else
work.d[399] -= settings.kkt_reg;
work.d_inv[399] = 1/work.d[399];
work.L[1436] = (work.KKT[797]-work.L[1435]*work.v[398])*work.d_inv[399];
work.v[63] = work.L[148]*work.d[63];
work.v[400] = work.KKT[798]-work.L[148]*work.v[63];
work.d[400] = work.v[400];
if (work.d[400] > 0)
work.d[400] = -settings.kkt_reg;
else
work.d[400] -= settings.kkt_reg;
work.d_inv[400] = 1/work.d[400];
work.L[149] = (work.KKT[799])*work.d_inv[400];
work.v[400] = work.L[149]*work.d[400];
work.v[401] = 0-work.L[149]*work.v[400];
work.d[401] = work.v[401];
if (work.d[401] < 0)
work.d[401] = settings.kkt_reg;
else
work.d[401] += settings.kkt_reg;
work.d_inv[401] = 1/work.d[401];
work.L[151] = (work.KKT[800])*work.d_inv[401];
work.L[153] = (work.KKT[801])*work.d_inv[401];
work.v[64] = work.L[150]*work.d[64];
work.v[401] = work.L[151]*work.d[401];
work.v[402] = work.KKT[802]-work.L[150]*work.v[64]-work.L[151]*work.v[401];
work.d[402] = work.v[402];
if (work.d[402] > 0)
work.d[402] = -settings.kkt_reg;
else
work.d[402] -= settings.kkt_reg;
work.d_inv[402] = 1/work.d[402];
work.L[154] = (-work.L[153]*work.v[401])*work.d_inv[402];
work.L[1469] = (work.KKT[803])*work.d_inv[402];
work.v[65] = work.L[152]*work.d[65];
work.v[401] = work.L[153]*work.d[401];
work.v[402] = work.L[154]*work.d[402];
work.v[403] = work.KKT[804]-work.L[152]*work.v[65]-work.L[153]*work.v[401]-work.L[154]*work.v[402];
work.d[403] = work.v[403];
if (work.d[403] > 0)
work.d[403] = -settings.kkt_reg;
else
work.d[403] -= settings.kkt_reg;
work.d_inv[403] = 1/work.d[403];
work.L[1470] = (work.KKT[805]-work.L[1469]*work.v[402])*work.d_inv[403];
work.v[66] = work.L[155]*work.d[66];
work.v[404] = work.KKT[806]-work.L[155]*work.v[66];
work.d[404] = work.v[404];
if (work.d[404] > 0)
work.d[404] = -settings.kkt_reg;
else
work.d[404] -= settings.kkt_reg;
work.d_inv[404] = 1/work.d[404];
work.L[156] = (work.KKT[807])*work.d_inv[404];
work.v[404] = work.L[156]*work.d[404];
work.v[405] = 0-work.L[156]*work.v[404];
work.d[405] = work.v[405];
if (work.d[405] < 0)
work.d[405] = settings.kkt_reg;
else
work.d[405] += settings.kkt_reg;
work.d_inv[405] = 1/work.d[405];
work.L[158] = (work.KKT[808])*work.d_inv[405];
work.L[160] = (work.KKT[809])*work.d_inv[405];
work.v[67] = work.L[157]*work.d[67];
work.v[405] = work.L[158]*work.d[405];
work.v[406] = work.KKT[810]-work.L[157]*work.v[67]-work.L[158]*work.v[405];
work.d[406] = work.v[406];
if (work.d[406] > 0)
work.d[406] = -settings.kkt_reg;
else
work.d[406] -= settings.kkt_reg;
work.d_inv[406] = 1/work.d[406];
work.L[161] = (-work.L[160]*work.v[405])*work.d_inv[406];
work.L[1489] = (work.KKT[811])*work.d_inv[406];
work.v[68] = work.L[159]*work.d[68];
work.v[405] = work.L[160]*work.d[405];
work.v[406] = work.L[161]*work.d[406];
work.v[407] = work.KKT[812]-work.L[159]*work.v[68]-work.L[160]*work.v[405]-work.L[161]*work.v[406];
work.d[407] = work.v[407];
if (work.d[407] > 0)
work.d[407] = -settings.kkt_reg;
else
work.d[407] -= settings.kkt_reg;
work.d_inv[407] = 1/work.d[407];
work.L[1490] = (work.KKT[813]-work.L[1489]*work.v[406])*work.d_inv[407];
work.v[69] = work.L[162]*work.d[69];
work.v[408] = work.KKT[814]-work.L[162]*work.v[69];
work.d[408] = work.v[408];
if (work.d[408] > 0)
work.d[408] = -settings.kkt_reg;
else
work.d[408] -= settings.kkt_reg;
work.d_inv[408] = 1/work.d[408];
work.L[163] = (work.KKT[815])*work.d_inv[408];
work.v[408] = work.L[163]*work.d[408];
work.v[409] = 0-work.L[163]*work.v[408];
work.d[409] = work.v[409];
if (work.d[409] < 0)
work.d[409] = settings.kkt_reg;
else
work.d[409] += settings.kkt_reg;
work.d_inv[409] = 1/work.d[409];
work.L[165] = (work.KKT[816])*work.d_inv[409];
work.L[167] = (work.KKT[817])*work.d_inv[409];
work.v[70] = work.L[164]*work.d[70];
work.v[409] = work.L[165]*work.d[409];
work.v[410] = work.KKT[818]-work.L[164]*work.v[70]-work.L[165]*work.v[409];
work.d[410] = work.v[410];
if (work.d[410] > 0)
work.d[410] = -settings.kkt_reg;
else
work.d[410] -= settings.kkt_reg;
work.d_inv[410] = 1/work.d[410];
work.L[168] = (-work.L[167]*work.v[409])*work.d_inv[410];
work.L[1514] = (work.KKT[819])*work.d_inv[410];
work.v[71] = work.L[166]*work.d[71];
work.v[409] = work.L[167]*work.d[409];
work.v[410] = work.L[168]*work.d[410];
work.v[411] = work.KKT[820]-work.L[166]*work.v[71]-work.L[167]*work.v[409]-work.L[168]*work.v[410];
work.d[411] = work.v[411];
if (work.d[411] > 0)
work.d[411] = -settings.kkt_reg;
else
work.d[411] -= settings.kkt_reg;
work.d_inv[411] = 1/work.d[411];
work.L[1515] = (work.KKT[821]-work.L[1514]*work.v[410])*work.d_inv[411];
work.v[72] = work.L[169]*work.d[72];
work.v[412] = work.KKT[822]-work.L[169]*work.v[72];
work.d[412] = work.v[412];
if (work.d[412] > 0)
work.d[412] = -settings.kkt_reg;
else
work.d[412] -= settings.kkt_reg;
work.d_inv[412] = 1/work.d[412];
work.L[170] = (work.KKT[823])*work.d_inv[412];
work.v[412] = work.L[170]*work.d[412];
work.v[413] = 0-work.L[170]*work.v[412];
work.d[413] = work.v[413];
if (work.d[413] < 0)
work.d[413] = settings.kkt_reg;
else
work.d[413] += settings.kkt_reg;
work.d_inv[413] = 1/work.d[413];
work.L[172] = (work.KKT[824])*work.d_inv[413];
work.L[174] = (work.KKT[825])*work.d_inv[413];
work.v[73] = work.L[171]*work.d[73];
work.v[413] = work.L[172]*work.d[413];
work.v[414] = work.KKT[826]-work.L[171]*work.v[73]-work.L[172]*work.v[413];
work.d[414] = work.v[414];
if (work.d[414] > 0)
work.d[414] = -settings.kkt_reg;
else
work.d[414] -= settings.kkt_reg;
work.d_inv[414] = 1/work.d[414];
work.L[175] = (-work.L[174]*work.v[413])*work.d_inv[414];
work.L[769] = (work.KKT[827])*work.d_inv[414];
work.v[74] = work.L[173]*work.d[74];
work.v[413] = work.L[174]*work.d[413];
work.v[414] = work.L[175]*work.d[414];
work.v[415] = work.KKT[828]-work.L[173]*work.v[74]-work.L[174]*work.v[413]-work.L[175]*work.v[414];
work.d[415] = work.v[415];
if (work.d[415] > 0)
work.d[415] = -settings.kkt_reg;
else
work.d[415] -= settings.kkt_reg;
work.d_inv[415] = 1/work.d[415];
work.L[770] = (work.KKT[829]-work.L[769]*work.v[414])*work.d_inv[415];
work.v[75] = work.L[176]*work.d[75];
work.v[416] = work.KKT[830]-work.L[176]*work.v[75];
work.d[416] = work.v[416];
if (work.d[416] > 0)
work.d[416] = -settings.kkt_reg;
else
work.d[416] -= settings.kkt_reg;
work.d_inv[416] = 1/work.d[416];
work.L[177] = (work.KKT[831])*work.d_inv[416];
work.v[416] = work.L[177]*work.d[416];
work.v[417] = 0-work.L[177]*work.v[416];
work.d[417] = work.v[417];
if (work.d[417] < 0)
work.d[417] = settings.kkt_reg;
else
work.d[417] += settings.kkt_reg;
work.d_inv[417] = 1/work.d[417];
work.L[179] = (work.KKT[832])*work.d_inv[417];
work.L[181] = (work.KKT[833])*work.d_inv[417];
work.v[76] = work.L[178]*work.d[76];
work.v[417] = work.L[179]*work.d[417];
work.v[418] = work.KKT[834]-work.L[178]*work.v[76]-work.L[179]*work.v[417];
work.d[418] = work.v[418];
if (work.d[418] > 0)
work.d[418] = -settings.kkt_reg;
else
work.d[418] -= settings.kkt_reg;
work.d_inv[418] = 1/work.d[418];
work.L[182] = (-work.L[181]*work.v[417])*work.d_inv[418];
work.L[733] = (work.KKT[835])*work.d_inv[418];
work.v[77] = work.L[180]*work.d[77];
work.v[417] = work.L[181]*work.d[417];
work.v[418] = work.L[182]*work.d[418];
work.v[419] = work.KKT[836]-work.L[180]*work.v[77]-work.L[181]*work.v[417]-work.L[182]*work.v[418];
work.d[419] = work.v[419];
if (work.d[419] > 0)
work.d[419] = -settings.kkt_reg;
else
work.d[419] -= settings.kkt_reg;
work.d_inv[419] = 1/work.d[419];
work.L[734] = (work.KKT[837]-work.L[733]*work.v[418])*work.d_inv[419];
work.v[78] = work.L[183]*work.d[78];
work.v[420] = work.KKT[838]-work.L[183]*work.v[78];
work.d[420] = work.v[420];
if (work.d[420] > 0)
work.d[420] = -settings.kkt_reg;
else
work.d[420] -= settings.kkt_reg;
work.d_inv[420] = 1/work.d[420];
work.L[184] = (work.KKT[839])*work.d_inv[420];
work.v[420] = work.L[184]*work.d[420];
work.v[421] = 0-work.L[184]*work.v[420];
work.d[421] = work.v[421];
if (work.d[421] < 0)
work.d[421] = settings.kkt_reg;
else
work.d[421] += settings.kkt_reg;
work.d_inv[421] = 1/work.d[421];
work.L[186] = (work.KKT[840])*work.d_inv[421];
work.L[188] = (work.KKT[841])*work.d_inv[421];
work.v[79] = work.L[185]*work.d[79];
work.v[421] = work.L[186]*work.d[421];
work.v[422] = work.KKT[842]-work.L[185]*work.v[79]-work.L[186]*work.v[421];
work.d[422] = work.v[422];
if (work.d[422] > 0)
work.d[422] = -settings.kkt_reg;
else
work.d[422] -= settings.kkt_reg;
work.d_inv[422] = 1/work.d[422];
work.L[189] = (-work.L[188]*work.v[421])*work.d_inv[422];
work.L[739] = (work.KKT[843])*work.d_inv[422];
work.v[80] = work.L[187]*work.d[80];
work.v[421] = work.L[188]*work.d[421];
work.v[422] = work.L[189]*work.d[422];
work.v[423] = work.KKT[844]-work.L[187]*work.v[80]-work.L[188]*work.v[421]-work.L[189]*work.v[422];
work.d[423] = work.v[423];
if (work.d[423] > 0)
work.d[423] = -settings.kkt_reg;
else
work.d[423] -= settings.kkt_reg;
work.d_inv[423] = 1/work.d[423];
work.L[740] = (work.KKT[845]-work.L[739]*work.v[422])*work.d_inv[423];
work.v[81] = work.L[190]*work.d[81];
work.v[424] = work.KKT[846]-work.L[190]*work.v[81];
work.d[424] = work.v[424];
if (work.d[424] > 0)
work.d[424] = -settings.kkt_reg;
else
work.d[424] -= settings.kkt_reg;
work.d_inv[424] = 1/work.d[424];
work.L[191] = (work.KKT[847])*work.d_inv[424];
work.v[424] = work.L[191]*work.d[424];
work.v[425] = 0-work.L[191]*work.v[424];
work.d[425] = work.v[425];
if (work.d[425] < 0)
work.d[425] = settings.kkt_reg;
else
work.d[425] += settings.kkt_reg;
work.d_inv[425] = 1/work.d[425];
work.L[193] = (work.KKT[848])*work.d_inv[425];
work.L[195] = (work.KKT[849])*work.d_inv[425];
work.v[82] = work.L[192]*work.d[82];
work.v[425] = work.L[193]*work.d[425];
work.v[426] = work.KKT[850]-work.L[192]*work.v[82]-work.L[193]*work.v[425];
work.d[426] = work.v[426];
if (work.d[426] > 0)
work.d[426] = -settings.kkt_reg;
else
work.d[426] -= settings.kkt_reg;
work.d_inv[426] = 1/work.d[426];
work.L[196] = (-work.L[195]*work.v[425])*work.d_inv[426];
work.L[741] = (work.KKT[851])*work.d_inv[426];
work.L[760] = (work.KKT[852])*work.d_inv[426];
work.v[83] = work.L[194]*work.d[83];
work.v[425] = work.L[195]*work.d[425];
work.v[426] = work.L[196]*work.d[426];
work.v[427] = work.KKT[853]-work.L[194]*work.v[83]-work.L[195]*work.v[425]-work.L[196]*work.v[426];
work.d[427] = work.v[427];
if (work.d[427] > 0)
work.d[427] = -settings.kkt_reg;
else
work.d[427] -= settings.kkt_reg;
work.d_inv[427] = 1/work.d[427];
work.L[742] = (work.KKT[854]-work.L[741]*work.v[426])*work.d_inv[427];
work.L[761] = (work.KKT[855]-work.L[760]*work.v[426])*work.d_inv[427];
work.v[84] = work.L[197]*work.d[84];
work.v[428] = work.KKT[856]-work.L[197]*work.v[84];
work.d[428] = work.v[428];
if (work.d[428] > 0)
work.d[428] = -settings.kkt_reg;
else
work.d[428] -= settings.kkt_reg;
work.d_inv[428] = 1/work.d[428];
work.L[198] = (work.KKT[857])*work.d_inv[428];
work.v[428] = work.L[198]*work.d[428];
work.v[429] = 0-work.L[198]*work.v[428];
work.d[429] = work.v[429];
if (work.d[429] < 0)
work.d[429] = settings.kkt_reg;
else
work.d[429] += settings.kkt_reg;
work.d_inv[429] = 1/work.d[429];
work.L[200] = (work.KKT[858])*work.d_inv[429];
work.L[202] = (work.KKT[859])*work.d_inv[429];
work.v[85] = work.L[199]*work.d[85];
work.v[429] = work.L[200]*work.d[429];
work.v[430] = work.KKT[860]-work.L[199]*work.v[85]-work.L[200]*work.v[429];
work.d[430] = work.v[430];
if (work.d[430] > 0)
work.d[430] = -settings.kkt_reg;
else
work.d[430] -= settings.kkt_reg;
work.d_inv[430] = 1/work.d[430];
work.L[203] = (-work.L[202]*work.v[429])*work.d_inv[430];
work.L[762] = (work.KKT[861])*work.d_inv[430];
work.L[822] = (work.KKT[862])*work.d_inv[430];
work.v[86] = work.L[201]*work.d[86];
work.v[429] = work.L[202]*work.d[429];
work.v[430] = work.L[203]*work.d[430];
work.v[431] = work.KKT[863]-work.L[201]*work.v[86]-work.L[202]*work.v[429]-work.L[203]*work.v[430];
work.d[431] = work.v[431];
if (work.d[431] > 0)
work.d[431] = -settings.kkt_reg;
else
work.d[431] -= settings.kkt_reg;
work.d_inv[431] = 1/work.d[431];
work.L[763] = (work.KKT[864]-work.L[762]*work.v[430])*work.d_inv[431];
work.L[823] = (work.KKT[865]-work.L[822]*work.v[430])*work.d_inv[431];
work.v[87] = work.L[204]*work.d[87];
work.v[432] = work.KKT[866]-work.L[204]*work.v[87];
work.d[432] = work.v[432];
if (work.d[432] > 0)
work.d[432] = -settings.kkt_reg;
else
work.d[432] -= settings.kkt_reg;
work.d_inv[432] = 1/work.d[432];
work.L[205] = (work.KKT[867])*work.d_inv[432];
work.v[432] = work.L[205]*work.d[432];
work.v[433] = 0-work.L[205]*work.v[432];
work.d[433] = work.v[433];
if (work.d[433] < 0)
work.d[433] = settings.kkt_reg;
else
work.d[433] += settings.kkt_reg;
work.d_inv[433] = 1/work.d[433];
work.L[207] = (work.KKT[868])*work.d_inv[433];
work.L[209] = (work.KKT[869])*work.d_inv[433];
work.v[88] = work.L[206]*work.d[88];
work.v[433] = work.L[207]*work.d[433];
work.v[434] = work.KKT[870]-work.L[206]*work.v[88]-work.L[207]*work.v[433];
work.d[434] = work.v[434];
if (work.d[434] > 0)
work.d[434] = -settings.kkt_reg;
else
work.d[434] -= settings.kkt_reg;
work.d_inv[434] = 1/work.d[434];
work.L[210] = (-work.L[209]*work.v[433])*work.d_inv[434];
work.L[824] = (work.KKT[871])*work.d_inv[434];
work.L[859] = (work.KKT[872])*work.d_inv[434];
work.v[89] = work.L[208]*work.d[89];
work.v[433] = work.L[209]*work.d[433];
work.v[434] = work.L[210]*work.d[434];
work.v[435] = work.KKT[873]-work.L[208]*work.v[89]-work.L[209]*work.v[433]-work.L[210]*work.v[434];
work.d[435] = work.v[435];
if (work.d[435] > 0)
work.d[435] = -settings.kkt_reg;
else
work.d[435] -= settings.kkt_reg;
work.d_inv[435] = 1/work.d[435];
work.L[825] = (work.KKT[874]-work.L[824]*work.v[434])*work.d_inv[435];
work.L[860] = (work.KKT[875]-work.L[859]*work.v[434])*work.d_inv[435];
work.v[90] = work.L[211]*work.d[90];
work.v[436] = work.KKT[876]-work.L[211]*work.v[90];
work.d[436] = work.v[436];
if (work.d[436] > 0)
work.d[436] = -settings.kkt_reg;
else
work.d[436] -= settings.kkt_reg;
work.d_inv[436] = 1/work.d[436];
work.L[212] = (work.KKT[877])*work.d_inv[436];
work.v[436] = work.L[212]*work.d[436];
work.v[437] = 0-work.L[212]*work.v[436];
work.d[437] = work.v[437];
if (work.d[437] < 0)
work.d[437] = settings.kkt_reg;
else
work.d[437] += settings.kkt_reg;
work.d_inv[437] = 1/work.d[437];
work.L[214] = (work.KKT[878])*work.d_inv[437];
work.L[216] = (work.KKT[879])*work.d_inv[437];
work.v[91] = work.L[213]*work.d[91];
work.v[437] = work.L[214]*work.d[437];
work.v[438] = work.KKT[880]-work.L[213]*work.v[91]-work.L[214]*work.v[437];
work.d[438] = work.v[438];
if (work.d[438] > 0)
work.d[438] = -settings.kkt_reg;
else
work.d[438] -= settings.kkt_reg;
work.d_inv[438] = 1/work.d[438];
work.L[217] = (-work.L[216]*work.v[437])*work.d_inv[438];
work.L[861] = (work.KKT[881])*work.d_inv[438];
work.L[893] = (work.KKT[882])*work.d_inv[438];
work.v[92] = work.L[215]*work.d[92];
work.v[437] = work.L[216]*work.d[437];
work.v[438] = work.L[217]*work.d[438];
work.v[439] = work.KKT[883]-work.L[215]*work.v[92]-work.L[216]*work.v[437]-work.L[217]*work.v[438];
work.d[439] = work.v[439];
if (work.d[439] > 0)
work.d[439] = -settings.kkt_reg;
else
work.d[439] -= settings.kkt_reg;
work.d_inv[439] = 1/work.d[439];
work.L[862] = (work.KKT[884]-work.L[861]*work.v[438])*work.d_inv[439];
work.L[894] = (work.KKT[885]-work.L[893]*work.v[438])*work.d_inv[439];
work.v[93] = work.L[218]*work.d[93];
work.v[440] = work.KKT[886]-work.L[218]*work.v[93];
work.d[440] = work.v[440];
if (work.d[440] > 0)
work.d[440] = -settings.kkt_reg;
else
work.d[440] -= settings.kkt_reg;
work.d_inv[440] = 1/work.d[440];
work.L[219] = (work.KKT[887])*work.d_inv[440];
work.v[440] = work.L[219]*work.d[440];
work.v[441] = 0-work.L[219]*work.v[440];
work.d[441] = work.v[441];
if (work.d[441] < 0)
work.d[441] = settings.kkt_reg;
else
work.d[441] += settings.kkt_reg;
work.d_inv[441] = 1/work.d[441];
work.L[221] = (work.KKT[888])*work.d_inv[441];
work.L[223] = (work.KKT[889])*work.d_inv[441];
work.v[94] = work.L[220]*work.d[94];
work.v[441] = work.L[221]*work.d[441];
work.v[442] = work.KKT[890]-work.L[220]*work.v[94]-work.L[221]*work.v[441];
work.d[442] = work.v[442];
if (work.d[442] > 0)
work.d[442] = -settings.kkt_reg;
else
work.d[442] -= settings.kkt_reg;
work.d_inv[442] = 1/work.d[442];
work.L[224] = (-work.L[223]*work.v[441])*work.d_inv[442];
work.L[895] = (work.KKT[891])*work.d_inv[442];
work.L[927] = (work.KKT[892])*work.d_inv[442];
work.v[95] = work.L[222]*work.d[95];
work.v[441] = work.L[223]*work.d[441];
work.v[442] = work.L[224]*work.d[442];
work.v[443] = work.KKT[893]-work.L[222]*work.v[95]-work.L[223]*work.v[441]-work.L[224]*work.v[442];
work.d[443] = work.v[443];
if (work.d[443] > 0)
work.d[443] = -settings.kkt_reg;
else
work.d[443] -= settings.kkt_reg;
work.d_inv[443] = 1/work.d[443];
work.L[896] = (work.KKT[894]-work.L[895]*work.v[442])*work.d_inv[443];
work.L[928] = (work.KKT[895]-work.L[927]*work.v[442])*work.d_inv[443];
work.v[96] = work.L[225]*work.d[96];
work.v[444] = work.KKT[896]-work.L[225]*work.v[96];
work.d[444] = work.v[444];
if (work.d[444] > 0)
work.d[444] = -settings.kkt_reg;
else
work.d[444] -= settings.kkt_reg;
work.d_inv[444] = 1/work.d[444];
work.L[226] = (work.KKT[897])*work.d_inv[444];
work.v[444] = work.L[226]*work.d[444];
work.v[445] = 0-work.L[226]*work.v[444];
work.d[445] = work.v[445];
if (work.d[445] < 0)
work.d[445] = settings.kkt_reg;
else
work.d[445] += settings.kkt_reg;
work.d_inv[445] = 1/work.d[445];
work.L[228] = (work.KKT[898])*work.d_inv[445];
work.L[230] = (work.KKT[899])*work.d_inv[445];
work.v[97] = work.L[227]*work.d[97];
work.v[445] = work.L[228]*work.d[445];
work.v[446] = work.KKT[900]-work.L[227]*work.v[97]-work.L[228]*work.v[445];
work.d[446] = work.v[446];
if (work.d[446] > 0)
work.d[446] = -settings.kkt_reg;
else
work.d[446] -= settings.kkt_reg;
work.d_inv[446] = 1/work.d[446];
work.L[231] = (-work.L[230]*work.v[445])*work.d_inv[446];
work.L[929] = (work.KKT[901])*work.d_inv[446];
work.L[961] = (work.KKT[902])*work.d_inv[446];
work.v[98] = work.L[229]*work.d[98];
work.v[445] = work.L[230]*work.d[445];
work.v[446] = work.L[231]*work.d[446];
work.v[447] = work.KKT[903]-work.L[229]*work.v[98]-work.L[230]*work.v[445]-work.L[231]*work.v[446];
work.d[447] = work.v[447];
if (work.d[447] > 0)
work.d[447] = -settings.kkt_reg;
else
work.d[447] -= settings.kkt_reg;
work.d_inv[447] = 1/work.d[447];
work.L[930] = (work.KKT[904]-work.L[929]*work.v[446])*work.d_inv[447];
work.L[962] = (work.KKT[905]-work.L[961]*work.v[446])*work.d_inv[447];
work.v[99] = work.L[232]*work.d[99];
work.v[448] = work.KKT[906]-work.L[232]*work.v[99];
work.d[448] = work.v[448];
if (work.d[448] > 0)
work.d[448] = -settings.kkt_reg;
else
work.d[448] -= settings.kkt_reg;
work.d_inv[448] = 1/work.d[448];
work.L[233] = (work.KKT[907])*work.d_inv[448];
work.v[448] = work.L[233]*work.d[448];
work.v[449] = 0-work.L[233]*work.v[448];
work.d[449] = work.v[449];
if (work.d[449] < 0)
work.d[449] = settings.kkt_reg;
else
work.d[449] += settings.kkt_reg;
work.d_inv[449] = 1/work.d[449];
work.L[235] = (work.KKT[908])*work.d_inv[449];
work.L[237] = (work.KKT[909])*work.d_inv[449];
work.v[100] = work.L[234]*work.d[100];
work.v[449] = work.L[235]*work.d[449];
work.v[450] = work.KKT[910]-work.L[234]*work.v[100]-work.L[235]*work.v[449];
work.d[450] = work.v[450];
if (work.d[450] > 0)
work.d[450] = -settings.kkt_reg;
else
work.d[450] -= settings.kkt_reg;
work.d_inv[450] = 1/work.d[450];
work.L[238] = (-work.L[237]*work.v[449])*work.d_inv[450];
work.L[963] = (work.KKT[911])*work.d_inv[450];
work.L[995] = (work.KKT[912])*work.d_inv[450];
work.v[101] = work.L[236]*work.d[101];
work.v[449] = work.L[237]*work.d[449];
work.v[450] = work.L[238]*work.d[450];
work.v[451] = work.KKT[913]-work.L[236]*work.v[101]-work.L[237]*work.v[449]-work.L[238]*work.v[450];
work.d[451] = work.v[451];
if (work.d[451] > 0)
work.d[451] = -settings.kkt_reg;
else
work.d[451] -= settings.kkt_reg;
work.d_inv[451] = 1/work.d[451];
work.L[964] = (work.KKT[914]-work.L[963]*work.v[450])*work.d_inv[451];
work.L[996] = (work.KKT[915]-work.L[995]*work.v[450])*work.d_inv[451];
work.v[102] = work.L[239]*work.d[102];
work.v[452] = work.KKT[916]-work.L[239]*work.v[102];
work.d[452] = work.v[452];
if (work.d[452] > 0)
work.d[452] = -settings.kkt_reg;
else
work.d[452] -= settings.kkt_reg;
work.d_inv[452] = 1/work.d[452];
work.L[240] = (work.KKT[917])*work.d_inv[452];
work.v[452] = work.L[240]*work.d[452];
work.v[453] = 0-work.L[240]*work.v[452];
work.d[453] = work.v[453];
if (work.d[453] < 0)
work.d[453] = settings.kkt_reg;
else
work.d[453] += settings.kkt_reg;
work.d_inv[453] = 1/work.d[453];
work.L[242] = (work.KKT[918])*work.d_inv[453];
work.L[244] = (work.KKT[919])*work.d_inv[453];
work.v[103] = work.L[241]*work.d[103];
work.v[453] = work.L[242]*work.d[453];
work.v[454] = work.KKT[920]-work.L[241]*work.v[103]-work.L[242]*work.v[453];
work.d[454] = work.v[454];
if (work.d[454] > 0)
work.d[454] = -settings.kkt_reg;
else
work.d[454] -= settings.kkt_reg;
work.d_inv[454] = 1/work.d[454];
work.L[245] = (-work.L[244]*work.v[453])*work.d_inv[454];
work.L[997] = (work.KKT[921])*work.d_inv[454];
work.L[1029] = (work.KKT[922])*work.d_inv[454];
work.v[104] = work.L[243]*work.d[104];
work.v[453] = work.L[244]*work.d[453];
work.v[454] = work.L[245]*work.d[454];
work.v[455] = work.KKT[923]-work.L[243]*work.v[104]-work.L[244]*work.v[453]-work.L[245]*work.v[454];
work.d[455] = work.v[455];
if (work.d[455] > 0)
work.d[455] = -settings.kkt_reg;
else
work.d[455] -= settings.kkt_reg;
work.d_inv[455] = 1/work.d[455];
work.L[998] = (work.KKT[924]-work.L[997]*work.v[454])*work.d_inv[455];
work.L[1030] = (work.KKT[925]-work.L[1029]*work.v[454])*work.d_inv[455];
work.v[105] = work.L[246]*work.d[105];
work.v[456] = work.KKT[926]-work.L[246]*work.v[105];
work.d[456] = work.v[456];
if (work.d[456] > 0)
work.d[456] = -settings.kkt_reg;
else
work.d[456] -= settings.kkt_reg;
work.d_inv[456] = 1/work.d[456];
work.L[247] = (work.KKT[927])*work.d_inv[456];
work.v[456] = work.L[247]*work.d[456];
work.v[457] = 0-work.L[247]*work.v[456];
work.d[457] = work.v[457];
if (work.d[457] < 0)
work.d[457] = settings.kkt_reg;
else
work.d[457] += settings.kkt_reg;
work.d_inv[457] = 1/work.d[457];
work.L[249] = (work.KKT[928])*work.d_inv[457];
work.L[251] = (work.KKT[929])*work.d_inv[457];
work.v[106] = work.L[248]*work.d[106];
work.v[457] = work.L[249]*work.d[457];
work.v[458] = work.KKT[930]-work.L[248]*work.v[106]-work.L[249]*work.v[457];
work.d[458] = work.v[458];
if (work.d[458] > 0)
work.d[458] = -settings.kkt_reg;
else
work.d[458] -= settings.kkt_reg;
work.d_inv[458] = 1/work.d[458];
work.L[252] = (-work.L[251]*work.v[457])*work.d_inv[458];
work.L[1031] = (work.KKT[931])*work.d_inv[458];
work.L[1063] = (work.KKT[932])*work.d_inv[458];
work.v[107] = work.L[250]*work.d[107];
work.v[457] = work.L[251]*work.d[457];
work.v[458] = work.L[252]*work.d[458];
work.v[459] = work.KKT[933]-work.L[250]*work.v[107]-work.L[251]*work.v[457]-work.L[252]*work.v[458];
work.d[459] = work.v[459];
if (work.d[459] > 0)
work.d[459] = -settings.kkt_reg;
else
work.d[459] -= settings.kkt_reg;
work.d_inv[459] = 1/work.d[459];
work.L[1032] = (work.KKT[934]-work.L[1031]*work.v[458])*work.d_inv[459];
work.L[1064] = (work.KKT[935]-work.L[1063]*work.v[458])*work.d_inv[459];
work.v[108] = work.L[253]*work.d[108];
work.v[460] = work.KKT[936]-work.L[253]*work.v[108];
work.d[460] = work.v[460];
if (work.d[460] > 0)
work.d[460] = -settings.kkt_reg;
else
work.d[460] -= settings.kkt_reg;
work.d_inv[460] = 1/work.d[460];
work.L[254] = (work.KKT[937])*work.d_inv[460];
work.v[460] = work.L[254]*work.d[460];
work.v[461] = 0-work.L[254]*work.v[460];
work.d[461] = work.v[461];
if (work.d[461] < 0)
work.d[461] = settings.kkt_reg;
else
work.d[461] += settings.kkt_reg;
work.d_inv[461] = 1/work.d[461];
work.L[256] = (work.KKT[938])*work.d_inv[461];
work.L[258] = (work.KKT[939])*work.d_inv[461];
work.v[109] = work.L[255]*work.d[109];
work.v[461] = work.L[256]*work.d[461];
work.v[462] = work.KKT[940]-work.L[255]*work.v[109]-work.L[256]*work.v[461];
work.d[462] = work.v[462];
if (work.d[462] > 0)
work.d[462] = -settings.kkt_reg;
else
work.d[462] -= settings.kkt_reg;
work.d_inv[462] = 1/work.d[462];
work.L[259] = (-work.L[258]*work.v[461])*work.d_inv[462];
work.L[1065] = (work.KKT[941])*work.d_inv[462];
work.L[1097] = (work.KKT[942])*work.d_inv[462];
work.v[110] = work.L[257]*work.d[110];
work.v[461] = work.L[258]*work.d[461];
work.v[462] = work.L[259]*work.d[462];
work.v[463] = work.KKT[943]-work.L[257]*work.v[110]-work.L[258]*work.v[461]-work.L[259]*work.v[462];
work.d[463] = work.v[463];
if (work.d[463] > 0)
work.d[463] = -settings.kkt_reg;
else
work.d[463] -= settings.kkt_reg;
work.d_inv[463] = 1/work.d[463];
work.L[1066] = (work.KKT[944]-work.L[1065]*work.v[462])*work.d_inv[463];
work.L[1098] = (work.KKT[945]-work.L[1097]*work.v[462])*work.d_inv[463];
work.v[111] = work.L[260]*work.d[111];
work.v[464] = work.KKT[946]-work.L[260]*work.v[111];
work.d[464] = work.v[464];
if (work.d[464] > 0)
work.d[464] = -settings.kkt_reg;
else
work.d[464] -= settings.kkt_reg;
work.d_inv[464] = 1/work.d[464];
work.L[261] = (work.KKT[947])*work.d_inv[464];
work.v[464] = work.L[261]*work.d[464];
work.v[465] = 0-work.L[261]*work.v[464];
work.d[465] = work.v[465];
if (work.d[465] < 0)
work.d[465] = settings.kkt_reg;
else
work.d[465] += settings.kkt_reg;
work.d_inv[465] = 1/work.d[465];
work.L[263] = (work.KKT[948])*work.d_inv[465];
work.L[265] = (work.KKT[949])*work.d_inv[465];
work.v[112] = work.L[262]*work.d[112];
work.v[465] = work.L[263]*work.d[465];
work.v[466] = work.KKT[950]-work.L[262]*work.v[112]-work.L[263]*work.v[465];
work.d[466] = work.v[466];
if (work.d[466] > 0)
work.d[466] = -settings.kkt_reg;
else
work.d[466] -= settings.kkt_reg;
work.d_inv[466] = 1/work.d[466];
work.L[266] = (-work.L[265]*work.v[465])*work.d_inv[466];
work.L[1099] = (work.KKT[951])*work.d_inv[466];
work.L[1131] = (work.KKT[952])*work.d_inv[466];
work.v[113] = work.L[264]*work.d[113];
work.v[465] = work.L[265]*work.d[465];
work.v[466] = work.L[266]*work.d[466];
work.v[467] = work.KKT[953]-work.L[264]*work.v[113]-work.L[265]*work.v[465]-work.L[266]*work.v[466];
work.d[467] = work.v[467];
if (work.d[467] > 0)
work.d[467] = -settings.kkt_reg;
else
work.d[467] -= settings.kkt_reg;
work.d_inv[467] = 1/work.d[467];
work.L[1100] = (work.KKT[954]-work.L[1099]*work.v[466])*work.d_inv[467];
work.L[1132] = (work.KKT[955]-work.L[1131]*work.v[466])*work.d_inv[467];
work.v[114] = work.L[267]*work.d[114];
work.v[468] = work.KKT[956]-work.L[267]*work.v[114];
work.d[468] = work.v[468];
if (work.d[468] > 0)
work.d[468] = -settings.kkt_reg;
else
work.d[468] -= settings.kkt_reg;
work.d_inv[468] = 1/work.d[468];
work.L[268] = (work.KKT[957])*work.d_inv[468];
work.v[468] = work.L[268]*work.d[468];
work.v[469] = 0-work.L[268]*work.v[468];
work.d[469] = work.v[469];
if (work.d[469] < 0)
work.d[469] = settings.kkt_reg;
else
work.d[469] += settings.kkt_reg;
work.d_inv[469] = 1/work.d[469];
work.L[270] = (work.KKT[958])*work.d_inv[469];
work.L[272] = (work.KKT[959])*work.d_inv[469];
work.v[115] = work.L[269]*work.d[115];
work.v[469] = work.L[270]*work.d[469];
work.v[470] = work.KKT[960]-work.L[269]*work.v[115]-work.L[270]*work.v[469];
work.d[470] = work.v[470];
if (work.d[470] > 0)
work.d[470] = -settings.kkt_reg;
else
work.d[470] -= settings.kkt_reg;
work.d_inv[470] = 1/work.d[470];
work.L[273] = (-work.L[272]*work.v[469])*work.d_inv[470];
work.L[1133] = (work.KKT[961])*work.d_inv[470];
work.L[1165] = (work.KKT[962])*work.d_inv[470];
work.v[116] = work.L[271]*work.d[116];
work.v[469] = work.L[272]*work.d[469];
work.v[470] = work.L[273]*work.d[470];
work.v[471] = work.KKT[963]-work.L[271]*work.v[116]-work.L[272]*work.v[469]-work.L[273]*work.v[470];
work.d[471] = work.v[471];
if (work.d[471] > 0)
work.d[471] = -settings.kkt_reg;
else
work.d[471] -= settings.kkt_reg;
work.d_inv[471] = 1/work.d[471];
work.L[1134] = (work.KKT[964]-work.L[1133]*work.v[470])*work.d_inv[471];
work.L[1166] = (work.KKT[965]-work.L[1165]*work.v[470])*work.d_inv[471];
work.v[117] = work.L[274]*work.d[117];
work.v[472] = work.KKT[966]-work.L[274]*work.v[117];
work.d[472] = work.v[472];
if (work.d[472] > 0)
work.d[472] = -settings.kkt_reg;
else
work.d[472] -= settings.kkt_reg;
work.d_inv[472] = 1/work.d[472];
work.L[275] = (work.KKT[967])*work.d_inv[472];
work.v[472] = work.L[275]*work.d[472];
work.v[473] = 0-work.L[275]*work.v[472];
work.d[473] = work.v[473];
if (work.d[473] < 0)
work.d[473] = settings.kkt_reg;
else
work.d[473] += settings.kkt_reg;
work.d_inv[473] = 1/work.d[473];
work.L[277] = (work.KKT[968])*work.d_inv[473];
work.L[279] = (work.KKT[969])*work.d_inv[473];
work.v[118] = work.L[276]*work.d[118];
work.v[473] = work.L[277]*work.d[473];
work.v[474] = work.KKT[970]-work.L[276]*work.v[118]-work.L[277]*work.v[473];
work.d[474] = work.v[474];
if (work.d[474] > 0)
work.d[474] = -settings.kkt_reg;
else
work.d[474] -= settings.kkt_reg;
work.d_inv[474] = 1/work.d[474];
work.L[280] = (-work.L[279]*work.v[473])*work.d_inv[474];
work.L[1167] = (work.KKT[971])*work.d_inv[474];
work.L[1199] = (work.KKT[972])*work.d_inv[474];
work.v[119] = work.L[278]*work.d[119];
work.v[473] = work.L[279]*work.d[473];
work.v[474] = work.L[280]*work.d[474];
work.v[475] = work.KKT[973]-work.L[278]*work.v[119]-work.L[279]*work.v[473]-work.L[280]*work.v[474];
work.d[475] = work.v[475];
if (work.d[475] > 0)
work.d[475] = -settings.kkt_reg;
else
work.d[475] -= settings.kkt_reg;
work.d_inv[475] = 1/work.d[475];
work.L[1168] = (work.KKT[974]-work.L[1167]*work.v[474])*work.d_inv[475];
work.L[1200] = (work.KKT[975]-work.L[1199]*work.v[474])*work.d_inv[475];
work.v[120] = work.L[281]*work.d[120];
work.v[476] = work.KKT[976]-work.L[281]*work.v[120];
work.d[476] = work.v[476];
if (work.d[476] > 0)
work.d[476] = -settings.kkt_reg;
else
work.d[476] -= settings.kkt_reg;
work.d_inv[476] = 1/work.d[476];
work.L[282] = (work.KKT[977])*work.d_inv[476];
work.v[476] = work.L[282]*work.d[476];
work.v[477] = 0-work.L[282]*work.v[476];
work.d[477] = work.v[477];
if (work.d[477] < 0)
work.d[477] = settings.kkt_reg;
else
work.d[477] += settings.kkt_reg;
work.d_inv[477] = 1/work.d[477];
work.L[284] = (work.KKT[978])*work.d_inv[477];
work.L[286] = (work.KKT[979])*work.d_inv[477];
work.v[121] = work.L[283]*work.d[121];
work.v[477] = work.L[284]*work.d[477];
work.v[478] = work.KKT[980]-work.L[283]*work.v[121]-work.L[284]*work.v[477];
work.d[478] = work.v[478];
if (work.d[478] > 0)
work.d[478] = -settings.kkt_reg;
else
work.d[478] -= settings.kkt_reg;
work.d_inv[478] = 1/work.d[478];
work.L[287] = (-work.L[286]*work.v[477])*work.d_inv[478];
work.L[1201] = (work.KKT[981])*work.d_inv[478];
work.L[1233] = (work.KKT[982])*work.d_inv[478];
work.v[122] = work.L[285]*work.d[122];
work.v[477] = work.L[286]*work.d[477];
work.v[478] = work.L[287]*work.d[478];
work.v[479] = work.KKT[983]-work.L[285]*work.v[122]-work.L[286]*work.v[477]-work.L[287]*work.v[478];
work.d[479] = work.v[479];
if (work.d[479] > 0)
work.d[479] = -settings.kkt_reg;
else
work.d[479] -= settings.kkt_reg;
work.d_inv[479] = 1/work.d[479];
work.L[1202] = (work.KKT[984]-work.L[1201]*work.v[478])*work.d_inv[479];
work.L[1234] = (work.KKT[985]-work.L[1233]*work.v[478])*work.d_inv[479];
work.v[123] = work.L[288]*work.d[123];
work.v[480] = work.KKT[986]-work.L[288]*work.v[123];
work.d[480] = work.v[480];
if (work.d[480] > 0)
work.d[480] = -settings.kkt_reg;
else
work.d[480] -= settings.kkt_reg;
work.d_inv[480] = 1/work.d[480];
work.L[289] = (work.KKT[987])*work.d_inv[480];
work.v[480] = work.L[289]*work.d[480];
work.v[481] = 0-work.L[289]*work.v[480];
work.d[481] = work.v[481];
if (work.d[481] < 0)
work.d[481] = settings.kkt_reg;
else
work.d[481] += settings.kkt_reg;
work.d_inv[481] = 1/work.d[481];
work.L[291] = (work.KKT[988])*work.d_inv[481];
work.L[293] = (work.KKT[989])*work.d_inv[481];
work.v[124] = work.L[290]*work.d[124];
work.v[481] = work.L[291]*work.d[481];
work.v[482] = work.KKT[990]-work.L[290]*work.v[124]-work.L[291]*work.v[481];
work.d[482] = work.v[482];
if (work.d[482] > 0)
work.d[482] = -settings.kkt_reg;
else
work.d[482] -= settings.kkt_reg;
work.d_inv[482] = 1/work.d[482];
work.L[294] = (-work.L[293]*work.v[481])*work.d_inv[482];
work.L[1235] = (work.KKT[991])*work.d_inv[482];
work.L[1267] = (work.KKT[992])*work.d_inv[482];
work.v[125] = work.L[292]*work.d[125];
work.v[481] = work.L[293]*work.d[481];
work.v[482] = work.L[294]*work.d[482];
work.v[483] = work.KKT[993]-work.L[292]*work.v[125]-work.L[293]*work.v[481]-work.L[294]*work.v[482];
work.d[483] = work.v[483];
if (work.d[483] > 0)
work.d[483] = -settings.kkt_reg;
else
work.d[483] -= settings.kkt_reg;
work.d_inv[483] = 1/work.d[483];
work.L[1236] = (work.KKT[994]-work.L[1235]*work.v[482])*work.d_inv[483];
work.L[1268] = (work.KKT[995]-work.L[1267]*work.v[482])*work.d_inv[483];
work.v[126] = work.L[295]*work.d[126];
work.v[484] = work.KKT[996]-work.L[295]*work.v[126];
work.d[484] = work.v[484];
if (work.d[484] > 0)
work.d[484] = -settings.kkt_reg;
else
work.d[484] -= settings.kkt_reg;
work.d_inv[484] = 1/work.d[484];
work.L[296] = (work.KKT[997])*work.d_inv[484];
work.v[484] = work.L[296]*work.d[484];
work.v[485] = 0-work.L[296]*work.v[484];
work.d[485] = work.v[485];
if (work.d[485] < 0)
work.d[485] = settings.kkt_reg;
else
work.d[485] += settings.kkt_reg;
work.d_inv[485] = 1/work.d[485];
work.L[298] = (work.KKT[998])*work.d_inv[485];
work.L[300] = (work.KKT[999])*work.d_inv[485];
work.v[127] = work.L[297]*work.d[127];
work.v[485] = work.L[298]*work.d[485];
work.v[486] = work.KKT[1000]-work.L[297]*work.v[127]-work.L[298]*work.v[485];
work.d[486] = work.v[486];
if (work.d[486] > 0)
work.d[486] = -settings.kkt_reg;
else
work.d[486] -= settings.kkt_reg;
work.d_inv[486] = 1/work.d[486];
work.L[301] = (-work.L[300]*work.v[485])*work.d_inv[486];
work.L[1269] = (work.KKT[1001])*work.d_inv[486];
work.L[1301] = (work.KKT[1002])*work.d_inv[486];
work.v[128] = work.L[299]*work.d[128];
work.v[485] = work.L[300]*work.d[485];
work.v[486] = work.L[301]*work.d[486];
work.v[487] = work.KKT[1003]-work.L[299]*work.v[128]-work.L[300]*work.v[485]-work.L[301]*work.v[486];
work.d[487] = work.v[487];
if (work.d[487] > 0)
work.d[487] = -settings.kkt_reg;
else
work.d[487] -= settings.kkt_reg;
work.d_inv[487] = 1/work.d[487];
work.L[1270] = (work.KKT[1004]-work.L[1269]*work.v[486])*work.d_inv[487];
work.L[1302] = (work.KKT[1005]-work.L[1301]*work.v[486])*work.d_inv[487];
work.v[129] = work.L[302]*work.d[129];
work.v[488] = work.KKT[1006]-work.L[302]*work.v[129];
work.d[488] = work.v[488];
if (work.d[488] > 0)
work.d[488] = -settings.kkt_reg;
else
work.d[488] -= settings.kkt_reg;
work.d_inv[488] = 1/work.d[488];
work.L[303] = (work.KKT[1007])*work.d_inv[488];
work.v[488] = work.L[303]*work.d[488];
work.v[489] = 0-work.L[303]*work.v[488];
work.d[489] = work.v[489];
if (work.d[489] < 0)
work.d[489] = settings.kkt_reg;
else
work.d[489] += settings.kkt_reg;
work.d_inv[489] = 1/work.d[489];
work.L[305] = (work.KKT[1008])*work.d_inv[489];
work.L[307] = (work.KKT[1009])*work.d_inv[489];
work.v[130] = work.L[304]*work.d[130];
work.v[489] = work.L[305]*work.d[489];
work.v[490] = work.KKT[1010]-work.L[304]*work.v[130]-work.L[305]*work.v[489];
work.d[490] = work.v[490];
if (work.d[490] > 0)
work.d[490] = -settings.kkt_reg;
else
work.d[490] -= settings.kkt_reg;
work.d_inv[490] = 1/work.d[490];
work.L[308] = (-work.L[307]*work.v[489])*work.d_inv[490];
work.L[1303] = (work.KKT[1011])*work.d_inv[490];
work.L[1335] = (work.KKT[1012])*work.d_inv[490];
work.v[131] = work.L[306]*work.d[131];
work.v[489] = work.L[307]*work.d[489];
work.v[490] = work.L[308]*work.d[490];
work.v[491] = work.KKT[1013]-work.L[306]*work.v[131]-work.L[307]*work.v[489]-work.L[308]*work.v[490];
work.d[491] = work.v[491];
if (work.d[491] > 0)
work.d[491] = -settings.kkt_reg;
else
work.d[491] -= settings.kkt_reg;
work.d_inv[491] = 1/work.d[491];
work.L[1304] = (work.KKT[1014]-work.L[1303]*work.v[490])*work.d_inv[491];
work.L[1336] = (work.KKT[1015]-work.L[1335]*work.v[490])*work.d_inv[491];
work.v[132] = work.L[309]*work.d[132];
work.v[492] = work.KKT[1016]-work.L[309]*work.v[132];
work.d[492] = work.v[492];
if (work.d[492] > 0)
work.d[492] = -settings.kkt_reg;
else
work.d[492] -= settings.kkt_reg;
work.d_inv[492] = 1/work.d[492];
work.L[310] = (work.KKT[1017])*work.d_inv[492];
work.v[492] = work.L[310]*work.d[492];
work.v[493] = 0-work.L[310]*work.v[492];
work.d[493] = work.v[493];
if (work.d[493] < 0)
work.d[493] = settings.kkt_reg;
else
work.d[493] += settings.kkt_reg;
work.d_inv[493] = 1/work.d[493];
work.L[312] = (work.KKT[1018])*work.d_inv[493];
work.L[314] = (work.KKT[1019])*work.d_inv[493];
work.v[133] = work.L[311]*work.d[133];
work.v[493] = work.L[312]*work.d[493];
work.v[494] = work.KKT[1020]-work.L[311]*work.v[133]-work.L[312]*work.v[493];
work.d[494] = work.v[494];
if (work.d[494] > 0)
work.d[494] = -settings.kkt_reg;
else
work.d[494] -= settings.kkt_reg;
work.d_inv[494] = 1/work.d[494];
work.L[315] = (-work.L[314]*work.v[493])*work.d_inv[494];
work.L[1337] = (work.KKT[1021])*work.d_inv[494];
work.L[1369] = (work.KKT[1022])*work.d_inv[494];
work.v[134] = work.L[313]*work.d[134];
work.v[493] = work.L[314]*work.d[493];
work.v[494] = work.L[315]*work.d[494];
work.v[495] = work.KKT[1023]-work.L[313]*work.v[134]-work.L[314]*work.v[493]-work.L[315]*work.v[494];
work.d[495] = work.v[495];
if (work.d[495] > 0)
work.d[495] = -settings.kkt_reg;
else
work.d[495] -= settings.kkt_reg;
work.d_inv[495] = 1/work.d[495];
work.L[1338] = (work.KKT[1024]-work.L[1337]*work.v[494])*work.d_inv[495];
work.L[1370] = (work.KKT[1025]-work.L[1369]*work.v[494])*work.d_inv[495];
work.v[135] = work.L[316]*work.d[135];
work.v[496] = work.KKT[1026]-work.L[316]*work.v[135];
work.d[496] = work.v[496];
if (work.d[496] > 0)
work.d[496] = -settings.kkt_reg;
else
work.d[496] -= settings.kkt_reg;
work.d_inv[496] = 1/work.d[496];
work.L[317] = (work.KKT[1027])*work.d_inv[496];
work.v[496] = work.L[317]*work.d[496];
work.v[497] = 0-work.L[317]*work.v[496];
work.d[497] = work.v[497];
if (work.d[497] < 0)
work.d[497] = settings.kkt_reg;
else
work.d[497] += settings.kkt_reg;
work.d_inv[497] = 1/work.d[497];
work.L[319] = (work.KKT[1028])*work.d_inv[497];
work.L[321] = (work.KKT[1029])*work.d_inv[497];
work.v[136] = work.L[318]*work.d[136];
work.v[497] = work.L[319]*work.d[497];
work.v[498] = work.KKT[1030]-work.L[318]*work.v[136]-work.L[319]*work.v[497];
work.d[498] = work.v[498];
if (work.d[498] > 0)
work.d[498] = -settings.kkt_reg;
else
work.d[498] -= settings.kkt_reg;
work.d_inv[498] = 1/work.d[498];
work.L[322] = (-work.L[321]*work.v[497])*work.d_inv[498];
work.L[1371] = (work.KKT[1031])*work.d_inv[498];
work.L[1403] = (work.KKT[1032])*work.d_inv[498];
work.v[137] = work.L[320]*work.d[137];
work.v[497] = work.L[321]*work.d[497];
work.v[498] = work.L[322]*work.d[498];
work.v[499] = work.KKT[1033]-work.L[320]*work.v[137]-work.L[321]*work.v[497]-work.L[322]*work.v[498];
work.d[499] = work.v[499];
if (work.d[499] > 0)
work.d[499] = -settings.kkt_reg;
else
work.d[499] -= settings.kkt_reg;
work.d_inv[499] = 1/work.d[499];
work.L[1372] = (work.KKT[1034]-work.L[1371]*work.v[498])*work.d_inv[499];
work.L[1404] = (work.KKT[1035]-work.L[1403]*work.v[498])*work.d_inv[499];
work.v[138] = work.L[323]*work.d[138];
work.v[500] = work.KKT[1036]-work.L[323]*work.v[138];
work.d[500] = work.v[500];
if (work.d[500] > 0)
work.d[500] = -settings.kkt_reg;
else
work.d[500] -= settings.kkt_reg;
work.d_inv[500] = 1/work.d[500];
work.L[324] = (work.KKT[1037])*work.d_inv[500];
work.v[500] = work.L[324]*work.d[500];
work.v[501] = 0-work.L[324]*work.v[500];
work.d[501] = work.v[501];
if (work.d[501] < 0)
work.d[501] = settings.kkt_reg;
else
work.d[501] += settings.kkt_reg;
work.d_inv[501] = 1/work.d[501];
work.L[326] = (work.KKT[1038])*work.d_inv[501];
work.L[328] = (work.KKT[1039])*work.d_inv[501];
work.v[139] = work.L[325]*work.d[139];
work.v[501] = work.L[326]*work.d[501];
work.v[502] = work.KKT[1040]-work.L[325]*work.v[139]-work.L[326]*work.v[501];
work.d[502] = work.v[502];
if (work.d[502] > 0)
work.d[502] = -settings.kkt_reg;
else
work.d[502] -= settings.kkt_reg;
work.d_inv[502] = 1/work.d[502];
work.L[329] = (-work.L[328]*work.v[501])*work.d_inv[502];
work.L[1405] = (work.KKT[1041])*work.d_inv[502];
work.L[1437] = (work.KKT[1042])*work.d_inv[502];
work.v[140] = work.L[327]*work.d[140];
work.v[501] = work.L[328]*work.d[501];
work.v[502] = work.L[329]*work.d[502];
work.v[503] = work.KKT[1043]-work.L[327]*work.v[140]-work.L[328]*work.v[501]-work.L[329]*work.v[502];
work.d[503] = work.v[503];
if (work.d[503] > 0)
work.d[503] = -settings.kkt_reg;
else
work.d[503] -= settings.kkt_reg;
work.d_inv[503] = 1/work.d[503];
work.L[1406] = (work.KKT[1044]-work.L[1405]*work.v[502])*work.d_inv[503];
work.L[1438] = (work.KKT[1045]-work.L[1437]*work.v[502])*work.d_inv[503];
work.v[141] = work.L[330]*work.d[141];
work.v[504] = work.KKT[1046]-work.L[330]*work.v[141];
work.d[504] = work.v[504];
if (work.d[504] > 0)
work.d[504] = -settings.kkt_reg;
else
work.d[504] -= settings.kkt_reg;
work.d_inv[504] = 1/work.d[504];
work.L[331] = (work.KKT[1047])*work.d_inv[504];
work.v[504] = work.L[331]*work.d[504];
work.v[505] = 0-work.L[331]*work.v[504];
work.d[505] = work.v[505];
if (work.d[505] < 0)
work.d[505] = settings.kkt_reg;
else
work.d[505] += settings.kkt_reg;
work.d_inv[505] = 1/work.d[505];
work.L[333] = (work.KKT[1048])*work.d_inv[505];
work.L[335] = (work.KKT[1049])*work.d_inv[505];
work.v[142] = work.L[332]*work.d[142];
work.v[505] = work.L[333]*work.d[505];
work.v[506] = work.KKT[1050]-work.L[332]*work.v[142]-work.L[333]*work.v[505];
work.d[506] = work.v[506];
if (work.d[506] > 0)
work.d[506] = -settings.kkt_reg;
else
work.d[506] -= settings.kkt_reg;
work.d_inv[506] = 1/work.d[506];
work.L[336] = (-work.L[335]*work.v[505])*work.d_inv[506];
work.L[1439] = (work.KKT[1051])*work.d_inv[506];
work.L[1471] = (work.KKT[1052])*work.d_inv[506];
work.v[143] = work.L[334]*work.d[143];
work.v[505] = work.L[335]*work.d[505];
work.v[506] = work.L[336]*work.d[506];
work.v[507] = work.KKT[1053]-work.L[334]*work.v[143]-work.L[335]*work.v[505]-work.L[336]*work.v[506];
work.d[507] = work.v[507];
if (work.d[507] > 0)
work.d[507] = -settings.kkt_reg;
else
work.d[507] -= settings.kkt_reg;
work.d_inv[507] = 1/work.d[507];
work.L[1440] = (work.KKT[1054]-work.L[1439]*work.v[506])*work.d_inv[507];
work.L[1472] = (work.KKT[1055]-work.L[1471]*work.v[506])*work.d_inv[507];
work.v[144] = work.L[337]*work.d[144];
work.v[508] = work.KKT[1056]-work.L[337]*work.v[144];
work.d[508] = work.v[508];
if (work.d[508] > 0)
work.d[508] = -settings.kkt_reg;
else
work.d[508] -= settings.kkt_reg;
work.d_inv[508] = 1/work.d[508];
work.L[338] = (work.KKT[1057])*work.d_inv[508];
work.v[508] = work.L[338]*work.d[508];
work.v[509] = 0-work.L[338]*work.v[508];
work.d[509] = work.v[509];
if (work.d[509] < 0)
work.d[509] = settings.kkt_reg;
else
work.d[509] += settings.kkt_reg;
work.d_inv[509] = 1/work.d[509];
work.L[340] = (work.KKT[1058])*work.d_inv[509];
work.L[342] = (work.KKT[1059])*work.d_inv[509];
work.v[145] = work.L[339]*work.d[145];
work.v[509] = work.L[340]*work.d[509];
work.v[510] = work.KKT[1060]-work.L[339]*work.v[145]-work.L[340]*work.v[509];
work.d[510] = work.v[510];
if (work.d[510] > 0)
work.d[510] = -settings.kkt_reg;
else
work.d[510] -= settings.kkt_reg;
work.d_inv[510] = 1/work.d[510];
work.L[343] = (-work.L[342]*work.v[509])*work.d_inv[510];
work.L[1473] = (work.KKT[1061])*work.d_inv[510];
work.L[1491] = (work.KKT[1062])*work.d_inv[510];
work.v[146] = work.L[341]*work.d[146];
work.v[509] = work.L[342]*work.d[509];
work.v[510] = work.L[343]*work.d[510];
work.v[511] = work.KKT[1063]-work.L[341]*work.v[146]-work.L[342]*work.v[509]-work.L[343]*work.v[510];
work.d[511] = work.v[511];
if (work.d[511] > 0)
work.d[511] = -settings.kkt_reg;
else
work.d[511] -= settings.kkt_reg;
work.d_inv[511] = 1/work.d[511];
work.L[1474] = (work.KKT[1064]-work.L[1473]*work.v[510])*work.d_inv[511];
work.L[1492] = (work.KKT[1065]-work.L[1491]*work.v[510])*work.d_inv[511];
work.v[147] = work.L[344]*work.d[147];
work.v[512] = work.KKT[1066]-work.L[344]*work.v[147];
work.d[512] = work.v[512];
if (work.d[512] > 0)
work.d[512] = -settings.kkt_reg;
else
work.d[512] -= settings.kkt_reg;
work.d_inv[512] = 1/work.d[512];
work.L[345] = (work.KKT[1067])*work.d_inv[512];
work.v[512] = work.L[345]*work.d[512];
work.v[513] = 0-work.L[345]*work.v[512];
work.d[513] = work.v[513];
if (work.d[513] < 0)
work.d[513] = settings.kkt_reg;
else
work.d[513] += settings.kkt_reg;
work.d_inv[513] = 1/work.d[513];
work.L[347] = (work.KKT[1068])*work.d_inv[513];
work.L[349] = (work.KKT[1069])*work.d_inv[513];
work.v[148] = work.L[346]*work.d[148];
work.v[513] = work.L[347]*work.d[513];
work.v[514] = work.KKT[1070]-work.L[346]*work.v[148]-work.L[347]*work.v[513];
work.d[514] = work.v[514];
if (work.d[514] > 0)
work.d[514] = -settings.kkt_reg;
else
work.d[514] -= settings.kkt_reg;
work.d_inv[514] = 1/work.d[514];
work.L[350] = (-work.L[349]*work.v[513])*work.d_inv[514];
work.L[1493] = (work.KKT[1071])*work.d_inv[514];
work.L[1516] = (work.KKT[1072])*work.d_inv[514];
work.v[149] = work.L[348]*work.d[149];
work.v[513] = work.L[349]*work.d[513];
work.v[514] = work.L[350]*work.d[514];
work.v[515] = work.KKT[1073]-work.L[348]*work.v[149]-work.L[349]*work.v[513]-work.L[350]*work.v[514];
work.d[515] = work.v[515];
if (work.d[515] > 0)
work.d[515] = -settings.kkt_reg;
else
work.d[515] -= settings.kkt_reg;
work.d_inv[515] = 1/work.d[515];
work.L[1494] = (work.KKT[1074]-work.L[1493]*work.v[514])*work.d_inv[515];
work.L[1517] = (work.KKT[1075]-work.L[1516]*work.v[514])*work.d_inv[515];
work.v[150] = work.L[351]*work.d[150];
work.v[516] = work.KKT[1076]-work.L[351]*work.v[150];
work.d[516] = work.v[516];
if (work.d[516] > 0)
work.d[516] = -settings.kkt_reg;
else
work.d[516] -= settings.kkt_reg;
work.d_inv[516] = 1/work.d[516];
work.L[352] = (work.KKT[1077])*work.d_inv[516];
work.v[516] = work.L[352]*work.d[516];
work.v[517] = 0-work.L[352]*work.v[516];
work.d[517] = work.v[517];
if (work.d[517] < 0)
work.d[517] = settings.kkt_reg;
else
work.d[517] += settings.kkt_reg;
work.d_inv[517] = 1/work.d[517];
work.L[354] = (work.KKT[1078])*work.d_inv[517];
work.L[356] = (work.KKT[1079])*work.d_inv[517];
work.v[151] = work.L[353]*work.d[151];
work.v[517] = work.L[354]*work.d[517];
work.v[518] = work.KKT[1080]-work.L[353]*work.v[151]-work.L[354]*work.v[517];
work.d[518] = work.v[518];
if (work.d[518] > 0)
work.d[518] = -settings.kkt_reg;
else
work.d[518] -= settings.kkt_reg;
work.d_inv[518] = 1/work.d[518];
work.L[357] = (-work.L[356]*work.v[517])*work.d_inv[518];
work.L[771] = (work.KKT[1081])*work.d_inv[518];
work.L[1518] = (work.KKT[1082])*work.d_inv[518];
work.v[152] = work.L[355]*work.d[152];
work.v[517] = work.L[356]*work.d[517];
work.v[518] = work.L[357]*work.d[518];
work.v[519] = work.KKT[1083]-work.L[355]*work.v[152]-work.L[356]*work.v[517]-work.L[357]*work.v[518];
work.d[519] = work.v[519];
if (work.d[519] > 0)
work.d[519] = -settings.kkt_reg;
else
work.d[519] -= settings.kkt_reg;
work.d_inv[519] = 1/work.d[519];
work.L[772] = (work.KKT[1084]-work.L[771]*work.v[518])*work.d_inv[519];
work.L[1519] = (work.KKT[1085]-work.L[1518]*work.v[518])*work.d_inv[519];
work.v[153] = work.L[358]*work.d[153];
work.v[520] = work.KKT[1086]-work.L[358]*work.v[153];
work.d[520] = work.v[520];
if (work.d[520] > 0)
work.d[520] = -settings.kkt_reg;
else
work.d[520] -= settings.kkt_reg;
work.d_inv[520] = 1/work.d[520];
work.L[359] = (work.KKT[1087])*work.d_inv[520];
work.v[520] = work.L[359]*work.d[520];
work.v[521] = 0-work.L[359]*work.v[520];
work.d[521] = work.v[521];
if (work.d[521] < 0)
work.d[521] = settings.kkt_reg;
else
work.d[521] += settings.kkt_reg;
work.d_inv[521] = 1/work.d[521];
work.L[361] = (work.KKT[1088])*work.d_inv[521];
work.L[363] = (work.KKT[1089])*work.d_inv[521];
work.v[154] = work.L[360]*work.d[154];
work.v[521] = work.L[361]*work.d[521];
work.v[522] = work.KKT[1090]-work.L[360]*work.v[154]-work.L[361]*work.v[521];
work.d[522] = work.v[522];
if (work.d[522] > 0)
work.d[522] = -settings.kkt_reg;
else
work.d[522] -= settings.kkt_reg;
work.d_inv[522] = 1/work.d[522];
work.L[364] = (-work.L[363]*work.v[521])*work.d_inv[522];
work.L[735] = (work.KKT[1091])*work.d_inv[522];
work.L[773] = (work.KKT[1092])*work.d_inv[522];
work.v[155] = work.L[362]*work.d[155];
work.v[521] = work.L[363]*work.d[521];
work.v[522] = work.L[364]*work.d[522];
work.v[523] = work.KKT[1093]-work.L[362]*work.v[155]-work.L[363]*work.v[521]-work.L[364]*work.v[522];
work.d[523] = work.v[523];
if (work.d[523] > 0)
work.d[523] = -settings.kkt_reg;
else
work.d[523] -= settings.kkt_reg;
work.d_inv[523] = 1/work.d[523];
work.L[736] = (work.KKT[1094]-work.L[735]*work.v[522])*work.d_inv[523];
work.L[774] = (work.KKT[1095]-work.L[773]*work.v[522])*work.d_inv[523];
work.v[156] = work.L[365]*work.d[156];
work.v[524] = work.KKT[1096]-work.L[365]*work.v[156];
work.d[524] = work.v[524];
if (work.d[524] > 0)
work.d[524] = -settings.kkt_reg;
else
work.d[524] -= settings.kkt_reg;
work.d_inv[524] = 1/work.d[524];
work.L[366] = (work.KKT[1097])*work.d_inv[524];
work.v[524] = work.L[366]*work.d[524];
work.v[525] = 0-work.L[366]*work.v[524];
work.d[525] = work.v[525];
if (work.d[525] < 0)
work.d[525] = settings.kkt_reg;
else
work.d[525] += settings.kkt_reg;
work.d_inv[525] = 1/work.d[525];
work.L[368] = (work.KKT[1098])*work.d_inv[525];
work.L[370] = (work.KKT[1099])*work.d_inv[525];
work.v[157] = work.L[367]*work.d[157];
work.v[525] = work.L[368]*work.d[525];
work.v[526] = work.KKT[1100]-work.L[367]*work.v[157]-work.L[368]*work.v[525];
work.d[526] = work.v[526];
if (work.d[526] > 0)
work.d[526] = -settings.kkt_reg;
else
work.d[526] -= settings.kkt_reg;
work.d_inv[526] = 1/work.d[526];
work.L[371] = (-work.L[370]*work.v[525])*work.d_inv[526];
work.L[750] = (work.KKT[1101])*work.d_inv[526];
work.v[158] = work.L[369]*work.d[158];
work.v[525] = work.L[370]*work.d[525];
work.v[526] = work.L[371]*work.d[526];
work.v[527] = work.KKT[1102]-work.L[369]*work.v[158]-work.L[370]*work.v[525]-work.L[371]*work.v[526];
work.d[527] = work.v[527];
if (work.d[527] > 0)
work.d[527] = -settings.kkt_reg;
else
work.d[527] -= settings.kkt_reg;
work.d_inv[527] = 1/work.d[527];
work.L[751] = (work.KKT[1103]-work.L[750]*work.v[526])*work.d_inv[527];
work.v[159] = work.L[372]*work.d[159];
work.v[528] = work.KKT[1104]-work.L[372]*work.v[159];
work.d[528] = work.v[528];
if (work.d[528] > 0)
work.d[528] = -settings.kkt_reg;
else
work.d[528] -= settings.kkt_reg;
work.d_inv[528] = 1/work.d[528];
work.L[373] = (work.KKT[1105])*work.d_inv[528];
work.v[528] = work.L[373]*work.d[528];
work.v[529] = 0-work.L[373]*work.v[528];
work.d[529] = work.v[529];
if (work.d[529] < 0)
work.d[529] = settings.kkt_reg;
else
work.d[529] += settings.kkt_reg;
work.d_inv[529] = 1/work.d[529];
work.L[375] = (work.KKT[1106])*work.d_inv[529];
work.L[377] = (work.KKT[1107])*work.d_inv[529];
work.v[160] = work.L[374]*work.d[160];
work.v[529] = work.L[375]*work.d[529];
work.v[530] = work.KKT[1108]-work.L[374]*work.v[160]-work.L[375]*work.v[529];
work.d[530] = work.v[530];
if (work.d[530] > 0)
work.d[530] = -settings.kkt_reg;
else
work.d[530] -= settings.kkt_reg;
work.d_inv[530] = 1/work.d[530];
work.L[378] = (-work.L[377]*work.v[529])*work.d_inv[530];
work.L[786] = (work.KKT[1109])*work.d_inv[530];
work.v[161] = work.L[376]*work.d[161];
work.v[529] = work.L[377]*work.d[529];
work.v[530] = work.L[378]*work.d[530];
work.v[531] = work.KKT[1110]-work.L[376]*work.v[161]-work.L[377]*work.v[529]-work.L[378]*work.v[530];
work.d[531] = work.v[531];
if (work.d[531] > 0)
work.d[531] = -settings.kkt_reg;
else
work.d[531] -= settings.kkt_reg;
work.d_inv[531] = 1/work.d[531];
work.L[787] = (work.KKT[1111]-work.L[786]*work.v[530])*work.d_inv[531];
work.v[162] = work.L[379]*work.d[162];
work.v[532] = work.KKT[1112]-work.L[379]*work.v[162];
work.d[532] = work.v[532];
if (work.d[532] > 0)
work.d[532] = -settings.kkt_reg;
else
work.d[532] -= settings.kkt_reg;
work.d_inv[532] = 1/work.d[532];
work.L[380] = (work.KKT[1113])*work.d_inv[532];
work.v[532] = work.L[380]*work.d[532];
work.v[533] = 0-work.L[380]*work.v[532];
work.d[533] = work.v[533];
if (work.d[533] < 0)
work.d[533] = settings.kkt_reg;
else
work.d[533] += settings.kkt_reg;
work.d_inv[533] = 1/work.d[533];
work.L[382] = (work.KKT[1114])*work.d_inv[533];
work.L[384] = (work.KKT[1115])*work.d_inv[533];
work.v[163] = work.L[381]*work.d[163];
work.v[533] = work.L[382]*work.d[533];
work.v[534] = work.KKT[1116]-work.L[381]*work.v[163]-work.L[382]*work.v[533];
work.d[534] = work.v[534];
if (work.d[534] > 0)
work.d[534] = -settings.kkt_reg;
else
work.d[534] -= settings.kkt_reg;
work.d_inv[534] = 1/work.d[534];
work.L[385] = (-work.L[384]*work.v[533])*work.d_inv[534];
work.L[808] = (work.KKT[1117])*work.d_inv[534];
work.v[164] = work.L[383]*work.d[164];
work.v[533] = work.L[384]*work.d[533];
work.v[534] = work.L[385]*work.d[534];
work.v[535] = work.KKT[1118]-work.L[383]*work.v[164]-work.L[384]*work.v[533]-work.L[385]*work.v[534];
work.d[535] = work.v[535];
if (work.d[535] > 0)
work.d[535] = -settings.kkt_reg;
else
work.d[535] -= settings.kkt_reg;
work.d_inv[535] = 1/work.d[535];
work.L[809] = (work.KKT[1119]-work.L[808]*work.v[534])*work.d_inv[535];
work.v[165] = work.L[386]*work.d[165];
work.v[536] = work.KKT[1120]-work.L[386]*work.v[165];
work.d[536] = work.v[536];
if (work.d[536] > 0)
work.d[536] = -settings.kkt_reg;
else
work.d[536] -= settings.kkt_reg;
work.d_inv[536] = 1/work.d[536];
work.L[387] = (work.KKT[1121])*work.d_inv[536];
work.v[536] = work.L[387]*work.d[536];
work.v[537] = 0-work.L[387]*work.v[536];
work.d[537] = work.v[537];
if (work.d[537] < 0)
work.d[537] = settings.kkt_reg;
else
work.d[537] += settings.kkt_reg;
work.d_inv[537] = 1/work.d[537];
work.L[389] = (work.KKT[1122])*work.d_inv[537];
work.L[391] = (work.KKT[1123])*work.d_inv[537];
work.v[166] = work.L[388]*work.d[166];
work.v[537] = work.L[389]*work.d[537];
work.v[538] = work.KKT[1124]-work.L[388]*work.v[166]-work.L[389]*work.v[537];
work.d[538] = work.v[538];
if (work.d[538] > 0)
work.d[538] = -settings.kkt_reg;
else
work.d[538] -= settings.kkt_reg;
work.d_inv[538] = 1/work.d[538];
work.L[392] = (-work.L[391]*work.v[537])*work.d_inv[538];
work.L[843] = (work.KKT[1125])*work.d_inv[538];
work.v[167] = work.L[390]*work.d[167];
work.v[537] = work.L[391]*work.d[537];
work.v[538] = work.L[392]*work.d[538];
work.v[539] = work.KKT[1126]-work.L[390]*work.v[167]-work.L[391]*work.v[537]-work.L[392]*work.v[538];
work.d[539] = work.v[539];
if (work.d[539] > 0)
work.d[539] = -settings.kkt_reg;
else
work.d[539] -= settings.kkt_reg;
work.d_inv[539] = 1/work.d[539];
work.L[844] = (work.KKT[1127]-work.L[843]*work.v[538])*work.d_inv[539];
work.v[168] = work.L[393]*work.d[168];
work.v[540] = work.KKT[1128]-work.L[393]*work.v[168];
work.d[540] = work.v[540];
if (work.d[540] > 0)
work.d[540] = -settings.kkt_reg;
else
work.d[540] -= settings.kkt_reg;
work.d_inv[540] = 1/work.d[540];
work.L[394] = (work.KKT[1129])*work.d_inv[540];
work.v[540] = work.L[394]*work.d[540];
work.v[541] = 0-work.L[394]*work.v[540];
work.d[541] = work.v[541];
if (work.d[541] < 0)
work.d[541] = settings.kkt_reg;
else
work.d[541] += settings.kkt_reg;
work.d_inv[541] = 1/work.d[541];
work.L[396] = (work.KKT[1130])*work.d_inv[541];
work.L[398] = (work.KKT[1131])*work.d_inv[541];
work.v[169] = work.L[395]*work.d[169];
work.v[541] = work.L[396]*work.d[541];
work.v[542] = work.KKT[1132]-work.L[395]*work.v[169]-work.L[396]*work.v[541];
work.d[542] = work.v[542];
if (work.d[542] > 0)
work.d[542] = -settings.kkt_reg;
else
work.d[542] -= settings.kkt_reg;
work.d_inv[542] = 1/work.d[542];
work.L[399] = (-work.L[398]*work.v[541])*work.d_inv[542];
work.L[877] = (work.KKT[1133])*work.d_inv[542];
work.v[170] = work.L[397]*work.d[170];
work.v[541] = work.L[398]*work.d[541];
work.v[542] = work.L[399]*work.d[542];
work.v[543] = work.KKT[1134]-work.L[397]*work.v[170]-work.L[398]*work.v[541]-work.L[399]*work.v[542];
work.d[543] = work.v[543];
if (work.d[543] > 0)
work.d[543] = -settings.kkt_reg;
else
work.d[543] -= settings.kkt_reg;
work.d_inv[543] = 1/work.d[543];
work.L[878] = (work.KKT[1135]-work.L[877]*work.v[542])*work.d_inv[543];
work.v[171] = work.L[400]*work.d[171];
work.v[544] = work.KKT[1136]-work.L[400]*work.v[171];
work.d[544] = work.v[544];
if (work.d[544] > 0)
work.d[544] = -settings.kkt_reg;
else
work.d[544] -= settings.kkt_reg;
work.d_inv[544] = 1/work.d[544];
work.L[401] = (work.KKT[1137])*work.d_inv[544];
work.v[544] = work.L[401]*work.d[544];
work.v[545] = 0-work.L[401]*work.v[544];
work.d[545] = work.v[545];
if (work.d[545] < 0)
work.d[545] = settings.kkt_reg;
else
work.d[545] += settings.kkt_reg;
work.d_inv[545] = 1/work.d[545];
work.L[403] = (work.KKT[1138])*work.d_inv[545];
work.L[405] = (work.KKT[1139])*work.d_inv[545];
work.v[172] = work.L[402]*work.d[172];
work.v[545] = work.L[403]*work.d[545];
work.v[546] = work.KKT[1140]-work.L[402]*work.v[172]-work.L[403]*work.v[545];
work.d[546] = work.v[546];
if (work.d[546] > 0)
work.d[546] = -settings.kkt_reg;
else
work.d[546] -= settings.kkt_reg;
work.d_inv[546] = 1/work.d[546];
work.L[406] = (-work.L[405]*work.v[545])*work.d_inv[546];
work.L[911] = (work.KKT[1141])*work.d_inv[546];
work.v[173] = work.L[404]*work.d[173];
work.v[545] = work.L[405]*work.d[545];
work.v[546] = work.L[406]*work.d[546];
work.v[547] = work.KKT[1142]-work.L[404]*work.v[173]-work.L[405]*work.v[545]-work.L[406]*work.v[546];
work.d[547] = work.v[547];
if (work.d[547] > 0)
work.d[547] = -settings.kkt_reg;
else
work.d[547] -= settings.kkt_reg;
work.d_inv[547] = 1/work.d[547];
work.L[912] = (work.KKT[1143]-work.L[911]*work.v[546])*work.d_inv[547];
work.v[174] = work.L[407]*work.d[174];
work.v[548] = work.KKT[1144]-work.L[407]*work.v[174];
work.d[548] = work.v[548];
if (work.d[548] > 0)
work.d[548] = -settings.kkt_reg;
else
work.d[548] -= settings.kkt_reg;
work.d_inv[548] = 1/work.d[548];
work.L[408] = (work.KKT[1145])*work.d_inv[548];
work.v[548] = work.L[408]*work.d[548];
work.v[549] = 0-work.L[408]*work.v[548];
work.d[549] = work.v[549];
if (work.d[549] < 0)
work.d[549] = settings.kkt_reg;
else
work.d[549] += settings.kkt_reg;
work.d_inv[549] = 1/work.d[549];
work.L[410] = (work.KKT[1146])*work.d_inv[549];
work.L[412] = (work.KKT[1147])*work.d_inv[549];
work.v[175] = work.L[409]*work.d[175];
work.v[549] = work.L[410]*work.d[549];
work.v[550] = work.KKT[1148]-work.L[409]*work.v[175]-work.L[410]*work.v[549];
work.d[550] = work.v[550];
if (work.d[550] > 0)
work.d[550] = -settings.kkt_reg;
else
work.d[550] -= settings.kkt_reg;
work.d_inv[550] = 1/work.d[550];
work.L[413] = (-work.L[412]*work.v[549])*work.d_inv[550];
work.L[945] = (work.KKT[1149])*work.d_inv[550];
work.v[176] = work.L[411]*work.d[176];
work.v[549] = work.L[412]*work.d[549];
work.v[550] = work.L[413]*work.d[550];
work.v[551] = work.KKT[1150]-work.L[411]*work.v[176]-work.L[412]*work.v[549]-work.L[413]*work.v[550];
work.d[551] = work.v[551];
if (work.d[551] > 0)
work.d[551] = -settings.kkt_reg;
else
work.d[551] -= settings.kkt_reg;
work.d_inv[551] = 1/work.d[551];
work.L[946] = (work.KKT[1151]-work.L[945]*work.v[550])*work.d_inv[551];
work.v[177] = work.L[414]*work.d[177];
work.v[552] = work.KKT[1152]-work.L[414]*work.v[177];
work.d[552] = work.v[552];
if (work.d[552] > 0)
work.d[552] = -settings.kkt_reg;
else
work.d[552] -= settings.kkt_reg;
work.d_inv[552] = 1/work.d[552];
work.L[415] = (work.KKT[1153])*work.d_inv[552];
work.v[552] = work.L[415]*work.d[552];
work.v[553] = 0-work.L[415]*work.v[552];
work.d[553] = work.v[553];
if (work.d[553] < 0)
work.d[553] = settings.kkt_reg;
else
work.d[553] += settings.kkt_reg;
work.d_inv[553] = 1/work.d[553];
work.L[417] = (work.KKT[1154])*work.d_inv[553];
work.L[419] = (work.KKT[1155])*work.d_inv[553];
work.v[178] = work.L[416]*work.d[178];
work.v[553] = work.L[417]*work.d[553];
work.v[554] = work.KKT[1156]-work.L[416]*work.v[178]-work.L[417]*work.v[553];
work.d[554] = work.v[554];
if (work.d[554] > 0)
work.d[554] = -settings.kkt_reg;
else
work.d[554] -= settings.kkt_reg;
work.d_inv[554] = 1/work.d[554];
work.L[420] = (-work.L[419]*work.v[553])*work.d_inv[554];
work.L[979] = (work.KKT[1157])*work.d_inv[554];
work.v[179] = work.L[418]*work.d[179];
work.v[553] = work.L[419]*work.d[553];
work.v[554] = work.L[420]*work.d[554];
work.v[555] = work.KKT[1158]-work.L[418]*work.v[179]-work.L[419]*work.v[553]-work.L[420]*work.v[554];
work.d[555] = work.v[555];
if (work.d[555] > 0)
work.d[555] = -settings.kkt_reg;
else
work.d[555] -= settings.kkt_reg;
work.d_inv[555] = 1/work.d[555];
work.L[980] = (work.KKT[1159]-work.L[979]*work.v[554])*work.d_inv[555];
work.v[180] = work.L[421]*work.d[180];
work.v[556] = work.KKT[1160]-work.L[421]*work.v[180];
work.d[556] = work.v[556];
if (work.d[556] > 0)
work.d[556] = -settings.kkt_reg;
else
work.d[556] -= settings.kkt_reg;
work.d_inv[556] = 1/work.d[556];
work.L[422] = (work.KKT[1161])*work.d_inv[556];
work.v[556] = work.L[422]*work.d[556];
work.v[557] = 0-work.L[422]*work.v[556];
work.d[557] = work.v[557];
if (work.d[557] < 0)
work.d[557] = settings.kkt_reg;
else
work.d[557] += settings.kkt_reg;
work.d_inv[557] = 1/work.d[557];
work.L[424] = (work.KKT[1162])*work.d_inv[557];
work.L[426] = (work.KKT[1163])*work.d_inv[557];
work.v[181] = work.L[423]*work.d[181];
work.v[557] = work.L[424]*work.d[557];
work.v[558] = work.KKT[1164]-work.L[423]*work.v[181]-work.L[424]*work.v[557];
work.d[558] = work.v[558];
if (work.d[558] > 0)
work.d[558] = -settings.kkt_reg;
else
work.d[558] -= settings.kkt_reg;
work.d_inv[558] = 1/work.d[558];
work.L[427] = (-work.L[426]*work.v[557])*work.d_inv[558];
work.L[1013] = (work.KKT[1165])*work.d_inv[558];
work.v[182] = work.L[425]*work.d[182];
work.v[557] = work.L[426]*work.d[557];
work.v[558] = work.L[427]*work.d[558];
work.v[559] = work.KKT[1166]-work.L[425]*work.v[182]-work.L[426]*work.v[557]-work.L[427]*work.v[558];
work.d[559] = work.v[559];
if (work.d[559] > 0)
work.d[559] = -settings.kkt_reg;
else
work.d[559] -= settings.kkt_reg;
work.d_inv[559] = 1/work.d[559];
work.L[1014] = (work.KKT[1167]-work.L[1013]*work.v[558])*work.d_inv[559];
work.v[183] = work.L[428]*work.d[183];
work.v[560] = work.KKT[1168]-work.L[428]*work.v[183];
work.d[560] = work.v[560];
if (work.d[560] > 0)
work.d[560] = -settings.kkt_reg;
else
work.d[560] -= settings.kkt_reg;
work.d_inv[560] = 1/work.d[560];
work.L[429] = (work.KKT[1169])*work.d_inv[560];
work.v[560] = work.L[429]*work.d[560];
work.v[561] = 0-work.L[429]*work.v[560];
work.d[561] = work.v[561];
if (work.d[561] < 0)
work.d[561] = settings.kkt_reg;
else
work.d[561] += settings.kkt_reg;
work.d_inv[561] = 1/work.d[561];
work.L[431] = (work.KKT[1170])*work.d_inv[561];
work.L[433] = (work.KKT[1171])*work.d_inv[561];
work.v[184] = work.L[430]*work.d[184];
work.v[561] = work.L[431]*work.d[561];
work.v[562] = work.KKT[1172]-work.L[430]*work.v[184]-work.L[431]*work.v[561];
work.d[562] = work.v[562];
if (work.d[562] > 0)
work.d[562] = -settings.kkt_reg;
else
work.d[562] -= settings.kkt_reg;
work.d_inv[562] = 1/work.d[562];
work.L[434] = (-work.L[433]*work.v[561])*work.d_inv[562];
work.L[1047] = (work.KKT[1173])*work.d_inv[562];
work.v[185] = work.L[432]*work.d[185];
work.v[561] = work.L[433]*work.d[561];
work.v[562] = work.L[434]*work.d[562];
work.v[563] = work.KKT[1174]-work.L[432]*work.v[185]-work.L[433]*work.v[561]-work.L[434]*work.v[562];
work.d[563] = work.v[563];
if (work.d[563] > 0)
work.d[563] = -settings.kkt_reg;
else
work.d[563] -= settings.kkt_reg;
work.d_inv[563] = 1/work.d[563];
work.L[1048] = (work.KKT[1175]-work.L[1047]*work.v[562])*work.d_inv[563];
work.v[186] = work.L[435]*work.d[186];
work.v[564] = work.KKT[1176]-work.L[435]*work.v[186];
work.d[564] = work.v[564];
if (work.d[564] > 0)
work.d[564] = -settings.kkt_reg;
else
work.d[564] -= settings.kkt_reg;
work.d_inv[564] = 1/work.d[564];
work.L[436] = (work.KKT[1177])*work.d_inv[564];
work.v[564] = work.L[436]*work.d[564];
work.v[565] = 0-work.L[436]*work.v[564];
work.d[565] = work.v[565];
if (work.d[565] < 0)
work.d[565] = settings.kkt_reg;
else
work.d[565] += settings.kkt_reg;
work.d_inv[565] = 1/work.d[565];
work.L[438] = (work.KKT[1178])*work.d_inv[565];
work.L[440] = (work.KKT[1179])*work.d_inv[565];
work.v[187] = work.L[437]*work.d[187];
work.v[565] = work.L[438]*work.d[565];
work.v[566] = work.KKT[1180]-work.L[437]*work.v[187]-work.L[438]*work.v[565];
work.d[566] = work.v[566];
if (work.d[566] > 0)
work.d[566] = -settings.kkt_reg;
else
work.d[566] -= settings.kkt_reg;
work.d_inv[566] = 1/work.d[566];
work.L[441] = (-work.L[440]*work.v[565])*work.d_inv[566];
work.L[1081] = (work.KKT[1181])*work.d_inv[566];
work.v[188] = work.L[439]*work.d[188];
work.v[565] = work.L[440]*work.d[565];
work.v[566] = work.L[441]*work.d[566];
work.v[567] = work.KKT[1182]-work.L[439]*work.v[188]-work.L[440]*work.v[565]-work.L[441]*work.v[566];
work.d[567] = work.v[567];
if (work.d[567] > 0)
work.d[567] = -settings.kkt_reg;
else
work.d[567] -= settings.kkt_reg;
work.d_inv[567] = 1/work.d[567];
work.L[1082] = (work.KKT[1183]-work.L[1081]*work.v[566])*work.d_inv[567];
work.v[189] = work.L[442]*work.d[189];
work.v[568] = work.KKT[1184]-work.L[442]*work.v[189];
work.d[568] = work.v[568];
if (work.d[568] > 0)
work.d[568] = -settings.kkt_reg;
else
work.d[568] -= settings.kkt_reg;
work.d_inv[568] = 1/work.d[568];
work.L[443] = (work.KKT[1185])*work.d_inv[568];
work.v[568] = work.L[443]*work.d[568];
work.v[569] = 0-work.L[443]*work.v[568];
work.d[569] = work.v[569];
if (work.d[569] < 0)
work.d[569] = settings.kkt_reg;
else
work.d[569] += settings.kkt_reg;
work.d_inv[569] = 1/work.d[569];
work.L[445] = (work.KKT[1186])*work.d_inv[569];
work.L[447] = (work.KKT[1187])*work.d_inv[569];
work.v[190] = work.L[444]*work.d[190];
work.v[569] = work.L[445]*work.d[569];
work.v[570] = work.KKT[1188]-work.L[444]*work.v[190]-work.L[445]*work.v[569];
work.d[570] = work.v[570];
if (work.d[570] > 0)
work.d[570] = -settings.kkt_reg;
else
work.d[570] -= settings.kkt_reg;
work.d_inv[570] = 1/work.d[570];
work.L[448] = (-work.L[447]*work.v[569])*work.d_inv[570];
work.L[1115] = (work.KKT[1189])*work.d_inv[570];
work.v[191] = work.L[446]*work.d[191];
work.v[569] = work.L[447]*work.d[569];
work.v[570] = work.L[448]*work.d[570];
work.v[571] = work.KKT[1190]-work.L[446]*work.v[191]-work.L[447]*work.v[569]-work.L[448]*work.v[570];
work.d[571] = work.v[571];
if (work.d[571] > 0)
work.d[571] = -settings.kkt_reg;
else
work.d[571] -= settings.kkt_reg;
work.d_inv[571] = 1/work.d[571];
work.L[1116] = (work.KKT[1191]-work.L[1115]*work.v[570])*work.d_inv[571];
work.v[192] = work.L[449]*work.d[192];
work.v[572] = work.KKT[1192]-work.L[449]*work.v[192];
work.d[572] = work.v[572];
if (work.d[572] > 0)
work.d[572] = -settings.kkt_reg;
else
work.d[572] -= settings.kkt_reg;
work.d_inv[572] = 1/work.d[572];
work.L[450] = (work.KKT[1193])*work.d_inv[572];
work.v[572] = work.L[450]*work.d[572];
work.v[573] = 0-work.L[450]*work.v[572];
work.d[573] = work.v[573];
if (work.d[573] < 0)
work.d[573] = settings.kkt_reg;
else
work.d[573] += settings.kkt_reg;
work.d_inv[573] = 1/work.d[573];
work.L[452] = (work.KKT[1194])*work.d_inv[573];
work.L[454] = (work.KKT[1195])*work.d_inv[573];
work.v[193] = work.L[451]*work.d[193];
work.v[573] = work.L[452]*work.d[573];
work.v[574] = work.KKT[1196]-work.L[451]*work.v[193]-work.L[452]*work.v[573];
work.d[574] = work.v[574];
if (work.d[574] > 0)
work.d[574] = -settings.kkt_reg;
else
work.d[574] -= settings.kkt_reg;
work.d_inv[574] = 1/work.d[574];
work.L[455] = (-work.L[454]*work.v[573])*work.d_inv[574];
work.L[1149] = (work.KKT[1197])*work.d_inv[574];
work.v[194] = work.L[453]*work.d[194];
work.v[573] = work.L[454]*work.d[573];
work.v[574] = work.L[455]*work.d[574];
work.v[575] = work.KKT[1198]-work.L[453]*work.v[194]-work.L[454]*work.v[573]-work.L[455]*work.v[574];
work.d[575] = work.v[575];
if (work.d[575] > 0)
work.d[575] = -settings.kkt_reg;
else
work.d[575] -= settings.kkt_reg;
work.d_inv[575] = 1/work.d[575];
work.L[1150] = (work.KKT[1199]-work.L[1149]*work.v[574])*work.d_inv[575];
work.v[195] = work.L[456]*work.d[195];
work.v[576] = work.KKT[1200]-work.L[456]*work.v[195];
work.d[576] = work.v[576];
if (work.d[576] > 0)
work.d[576] = -settings.kkt_reg;
else
work.d[576] -= settings.kkt_reg;
work.d_inv[576] = 1/work.d[576];
work.L[457] = (work.KKT[1201])*work.d_inv[576];
work.v[576] = work.L[457]*work.d[576];
work.v[577] = 0-work.L[457]*work.v[576];
work.d[577] = work.v[577];
if (work.d[577] < 0)
work.d[577] = settings.kkt_reg;
else
work.d[577] += settings.kkt_reg;
work.d_inv[577] = 1/work.d[577];
work.L[459] = (work.KKT[1202])*work.d_inv[577];
work.L[461] = (work.KKT[1203])*work.d_inv[577];
work.v[196] = work.L[458]*work.d[196];
work.v[577] = work.L[459]*work.d[577];
work.v[578] = work.KKT[1204]-work.L[458]*work.v[196]-work.L[459]*work.v[577];
work.d[578] = work.v[578];
if (work.d[578] > 0)
work.d[578] = -settings.kkt_reg;
else
work.d[578] -= settings.kkt_reg;
work.d_inv[578] = 1/work.d[578];
work.L[462] = (-work.L[461]*work.v[577])*work.d_inv[578];
work.L[1183] = (work.KKT[1205])*work.d_inv[578];
work.v[197] = work.L[460]*work.d[197];
work.v[577] = work.L[461]*work.d[577];
work.v[578] = work.L[462]*work.d[578];
work.v[579] = work.KKT[1206]-work.L[460]*work.v[197]-work.L[461]*work.v[577]-work.L[462]*work.v[578];
work.d[579] = work.v[579];
if (work.d[579] > 0)
work.d[579] = -settings.kkt_reg;
else
work.d[579] -= settings.kkt_reg;
work.d_inv[579] = 1/work.d[579];
work.L[1184] = (work.KKT[1207]-work.L[1183]*work.v[578])*work.d_inv[579];
work.v[198] = work.L[463]*work.d[198];
work.v[580] = work.KKT[1208]-work.L[463]*work.v[198];
work.d[580] = work.v[580];
if (work.d[580] > 0)
work.d[580] = -settings.kkt_reg;
else
work.d[580] -= settings.kkt_reg;
work.d_inv[580] = 1/work.d[580];
work.L[464] = (work.KKT[1209])*work.d_inv[580];
work.v[580] = work.L[464]*work.d[580];
work.v[581] = 0-work.L[464]*work.v[580];
work.d[581] = work.v[581];
if (work.d[581] < 0)
work.d[581] = settings.kkt_reg;
else
work.d[581] += settings.kkt_reg;
work.d_inv[581] = 1/work.d[581];
work.L[466] = (work.KKT[1210])*work.d_inv[581];
work.L[468] = (work.KKT[1211])*work.d_inv[581];
work.v[199] = work.L[465]*work.d[199];
work.v[581] = work.L[466]*work.d[581];
work.v[582] = work.KKT[1212]-work.L[465]*work.v[199]-work.L[466]*work.v[581];
work.d[582] = work.v[582];
if (work.d[582] > 0)
work.d[582] = -settings.kkt_reg;
else
work.d[582] -= settings.kkt_reg;
work.d_inv[582] = 1/work.d[582];
work.L[469] = (-work.L[468]*work.v[581])*work.d_inv[582];
work.L[1217] = (work.KKT[1213])*work.d_inv[582];
work.v[200] = work.L[467]*work.d[200];
work.v[581] = work.L[468]*work.d[581];
work.v[582] = work.L[469]*work.d[582];
work.v[583] = work.KKT[1214]-work.L[467]*work.v[200]-work.L[468]*work.v[581]-work.L[469]*work.v[582];
work.d[583] = work.v[583];
if (work.d[583] > 0)
work.d[583] = -settings.kkt_reg;
else
work.d[583] -= settings.kkt_reg;
work.d_inv[583] = 1/work.d[583];
work.L[1218] = (work.KKT[1215]-work.L[1217]*work.v[582])*work.d_inv[583];
work.v[201] = work.L[470]*work.d[201];
work.v[584] = work.KKT[1216]-work.L[470]*work.v[201];
work.d[584] = work.v[584];
if (work.d[584] > 0)
work.d[584] = -settings.kkt_reg;
else
work.d[584] -= settings.kkt_reg;
work.d_inv[584] = 1/work.d[584];
work.L[471] = (work.KKT[1217])*work.d_inv[584];
work.v[584] = work.L[471]*work.d[584];
work.v[585] = 0-work.L[471]*work.v[584];
work.d[585] = work.v[585];
if (work.d[585] < 0)
work.d[585] = settings.kkt_reg;
else
work.d[585] += settings.kkt_reg;
work.d_inv[585] = 1/work.d[585];
work.L[473] = (work.KKT[1218])*work.d_inv[585];
work.L[475] = (work.KKT[1219])*work.d_inv[585];
work.v[202] = work.L[472]*work.d[202];
work.v[585] = work.L[473]*work.d[585];
work.v[586] = work.KKT[1220]-work.L[472]*work.v[202]-work.L[473]*work.v[585];
work.d[586] = work.v[586];
if (work.d[586] > 0)
work.d[586] = -settings.kkt_reg;
else
work.d[586] -= settings.kkt_reg;
work.d_inv[586] = 1/work.d[586];
work.L[476] = (-work.L[475]*work.v[585])*work.d_inv[586];
work.L[1251] = (work.KKT[1221])*work.d_inv[586];
work.v[203] = work.L[474]*work.d[203];
work.v[585] = work.L[475]*work.d[585];
work.v[586] = work.L[476]*work.d[586];
work.v[587] = work.KKT[1222]-work.L[474]*work.v[203]-work.L[475]*work.v[585]-work.L[476]*work.v[586];
work.d[587] = work.v[587];
if (work.d[587] > 0)
work.d[587] = -settings.kkt_reg;
else
work.d[587] -= settings.kkt_reg;
work.d_inv[587] = 1/work.d[587];
work.L[1252] = (work.KKT[1223]-work.L[1251]*work.v[586])*work.d_inv[587];
work.v[204] = work.L[477]*work.d[204];
work.v[588] = work.KKT[1224]-work.L[477]*work.v[204];
work.d[588] = work.v[588];
if (work.d[588] > 0)
work.d[588] = -settings.kkt_reg;
else
work.d[588] -= settings.kkt_reg;
work.d_inv[588] = 1/work.d[588];
work.L[478] = (work.KKT[1225])*work.d_inv[588];
work.v[588] = work.L[478]*work.d[588];
work.v[589] = 0-work.L[478]*work.v[588];
work.d[589] = work.v[589];
if (work.d[589] < 0)
work.d[589] = settings.kkt_reg;
else
work.d[589] += settings.kkt_reg;
work.d_inv[589] = 1/work.d[589];
work.L[480] = (work.KKT[1226])*work.d_inv[589];
work.L[482] = (work.KKT[1227])*work.d_inv[589];
work.v[205] = work.L[479]*work.d[205];
work.v[589] = work.L[480]*work.d[589];
work.v[590] = work.KKT[1228]-work.L[479]*work.v[205]-work.L[480]*work.v[589];
work.d[590] = work.v[590];
if (work.d[590] > 0)
work.d[590] = -settings.kkt_reg;
else
work.d[590] -= settings.kkt_reg;
work.d_inv[590] = 1/work.d[590];
work.L[483] = (-work.L[482]*work.v[589])*work.d_inv[590];
work.L[1285] = (work.KKT[1229])*work.d_inv[590];
work.v[206] = work.L[481]*work.d[206];
work.v[589] = work.L[482]*work.d[589];
work.v[590] = work.L[483]*work.d[590];
work.v[591] = work.KKT[1230]-work.L[481]*work.v[206]-work.L[482]*work.v[589]-work.L[483]*work.v[590];
work.d[591] = work.v[591];
if (work.d[591] > 0)
work.d[591] = -settings.kkt_reg;
else
work.d[591] -= settings.kkt_reg;
work.d_inv[591] = 1/work.d[591];
work.L[1286] = (work.KKT[1231]-work.L[1285]*work.v[590])*work.d_inv[591];
work.v[207] = work.L[484]*work.d[207];
work.v[592] = work.KKT[1232]-work.L[484]*work.v[207];
work.d[592] = work.v[592];
if (work.d[592] > 0)
work.d[592] = -settings.kkt_reg;
else
work.d[592] -= settings.kkt_reg;
work.d_inv[592] = 1/work.d[592];
work.L[485] = (work.KKT[1233])*work.d_inv[592];
work.v[592] = work.L[485]*work.d[592];
work.v[593] = 0-work.L[485]*work.v[592];
work.d[593] = work.v[593];
if (work.d[593] < 0)
work.d[593] = settings.kkt_reg;
else
work.d[593] += settings.kkt_reg;
work.d_inv[593] = 1/work.d[593];
work.L[487] = (work.KKT[1234])*work.d_inv[593];
work.L[489] = (work.KKT[1235])*work.d_inv[593];
work.v[208] = work.L[486]*work.d[208];
work.v[593] = work.L[487]*work.d[593];
work.v[594] = work.KKT[1236]-work.L[486]*work.v[208]-work.L[487]*work.v[593];
work.d[594] = work.v[594];
if (work.d[594] > 0)
work.d[594] = -settings.kkt_reg;
else
work.d[594] -= settings.kkt_reg;
work.d_inv[594] = 1/work.d[594];
work.L[490] = (-work.L[489]*work.v[593])*work.d_inv[594];
work.L[1319] = (work.KKT[1237])*work.d_inv[594];
work.v[209] = work.L[488]*work.d[209];
work.v[593] = work.L[489]*work.d[593];
work.v[594] = work.L[490]*work.d[594];
work.v[595] = work.KKT[1238]-work.L[488]*work.v[209]-work.L[489]*work.v[593]-work.L[490]*work.v[594];
work.d[595] = work.v[595];
if (work.d[595] > 0)
work.d[595] = -settings.kkt_reg;
else
work.d[595] -= settings.kkt_reg;
work.d_inv[595] = 1/work.d[595];
work.L[1320] = (work.KKT[1239]-work.L[1319]*work.v[594])*work.d_inv[595];
work.v[210] = work.L[491]*work.d[210];
work.v[596] = work.KKT[1240]-work.L[491]*work.v[210];
work.d[596] = work.v[596];
if (work.d[596] > 0)
work.d[596] = -settings.kkt_reg;
else
work.d[596] -= settings.kkt_reg;
work.d_inv[596] = 1/work.d[596];
work.L[492] = (work.KKT[1241])*work.d_inv[596];
work.v[596] = work.L[492]*work.d[596];
work.v[597] = 0-work.L[492]*work.v[596];
work.d[597] = work.v[597];
if (work.d[597] < 0)
work.d[597] = settings.kkt_reg;
else
work.d[597] += settings.kkt_reg;
work.d_inv[597] = 1/work.d[597];
work.L[494] = (work.KKT[1242])*work.d_inv[597];
work.L[496] = (work.KKT[1243])*work.d_inv[597];
work.v[211] = work.L[493]*work.d[211];
work.v[597] = work.L[494]*work.d[597];
work.v[598] = work.KKT[1244]-work.L[493]*work.v[211]-work.L[494]*work.v[597];
work.d[598] = work.v[598];
if (work.d[598] > 0)
work.d[598] = -settings.kkt_reg;
else
work.d[598] -= settings.kkt_reg;
work.d_inv[598] = 1/work.d[598];
work.L[497] = (-work.L[496]*work.v[597])*work.d_inv[598];
work.L[1353] = (work.KKT[1245])*work.d_inv[598];
work.v[212] = work.L[495]*work.d[212];
work.v[597] = work.L[496]*work.d[597];
work.v[598] = work.L[497]*work.d[598];
work.v[599] = work.KKT[1246]-work.L[495]*work.v[212]-work.L[496]*work.v[597]-work.L[497]*work.v[598];
work.d[599] = work.v[599];
if (work.d[599] > 0)
work.d[599] = -settings.kkt_reg;
else
work.d[599] -= settings.kkt_reg;
work.d_inv[599] = 1/work.d[599];
work.L[1354] = (work.KKT[1247]-work.L[1353]*work.v[598])*work.d_inv[599];
work.v[213] = work.L[498]*work.d[213];
work.v[600] = work.KKT[1248]-work.L[498]*work.v[213];
work.d[600] = work.v[600];
if (work.d[600] > 0)
work.d[600] = -settings.kkt_reg;
else
work.d[600] -= settings.kkt_reg;
work.d_inv[600] = 1/work.d[600];
work.L[499] = (work.KKT[1249])*work.d_inv[600];
work.v[600] = work.L[499]*work.d[600];
work.v[601] = 0-work.L[499]*work.v[600];
work.d[601] = work.v[601];
if (work.d[601] < 0)
work.d[601] = settings.kkt_reg;
else
work.d[601] += settings.kkt_reg;
work.d_inv[601] = 1/work.d[601];
work.L[501] = (work.KKT[1250])*work.d_inv[601];
work.L[503] = (work.KKT[1251])*work.d_inv[601];
work.v[214] = work.L[500]*work.d[214];
work.v[601] = work.L[501]*work.d[601];
work.v[602] = work.KKT[1252]-work.L[500]*work.v[214]-work.L[501]*work.v[601];
work.d[602] = work.v[602];
if (work.d[602] > 0)
work.d[602] = -settings.kkt_reg;
else
work.d[602] -= settings.kkt_reg;
work.d_inv[602] = 1/work.d[602];
work.L[504] = (-work.L[503]*work.v[601])*work.d_inv[602];
work.L[1387] = (work.KKT[1253])*work.d_inv[602];
work.v[215] = work.L[502]*work.d[215];
work.v[601] = work.L[503]*work.d[601];
work.v[602] = work.L[504]*work.d[602];
work.v[603] = work.KKT[1254]-work.L[502]*work.v[215]-work.L[503]*work.v[601]-work.L[504]*work.v[602];
work.d[603] = work.v[603];
if (work.d[603] > 0)
work.d[603] = -settings.kkt_reg;
else
work.d[603] -= settings.kkt_reg;
work.d_inv[603] = 1/work.d[603];
work.L[1388] = (work.KKT[1255]-work.L[1387]*work.v[602])*work.d_inv[603];
work.v[216] = work.L[505]*work.d[216];
work.v[604] = work.KKT[1256]-work.L[505]*work.v[216];
work.d[604] = work.v[604];
if (work.d[604] > 0)
work.d[604] = -settings.kkt_reg;
else
work.d[604] -= settings.kkt_reg;
work.d_inv[604] = 1/work.d[604];
work.L[506] = (work.KKT[1257])*work.d_inv[604];
work.v[604] = work.L[506]*work.d[604];
work.v[605] = 0-work.L[506]*work.v[604];
work.d[605] = work.v[605];
if (work.d[605] < 0)
work.d[605] = settings.kkt_reg;
else
work.d[605] += settings.kkt_reg;
work.d_inv[605] = 1/work.d[605];
work.L[508] = (work.KKT[1258])*work.d_inv[605];
work.L[510] = (work.KKT[1259])*work.d_inv[605];
work.v[217] = work.L[507]*work.d[217];
work.v[605] = work.L[508]*work.d[605];
work.v[606] = work.KKT[1260]-work.L[507]*work.v[217]-work.L[508]*work.v[605];
work.d[606] = work.v[606];
if (work.d[606] > 0)
work.d[606] = -settings.kkt_reg;
else
work.d[606] -= settings.kkt_reg;
work.d_inv[606] = 1/work.d[606];
work.L[511] = (-work.L[510]*work.v[605])*work.d_inv[606];
work.L[1421] = (work.KKT[1261])*work.d_inv[606];
work.v[218] = work.L[509]*work.d[218];
work.v[605] = work.L[510]*work.d[605];
work.v[606] = work.L[511]*work.d[606];
work.v[607] = work.KKT[1262]-work.L[509]*work.v[218]-work.L[510]*work.v[605]-work.L[511]*work.v[606];
work.d[607] = work.v[607];
if (work.d[607] > 0)
work.d[607] = -settings.kkt_reg;
else
work.d[607] -= settings.kkt_reg;
work.d_inv[607] = 1/work.d[607];
work.L[1422] = (work.KKT[1263]-work.L[1421]*work.v[606])*work.d_inv[607];
work.v[219] = work.L[512]*work.d[219];
work.v[608] = work.KKT[1264]-work.L[512]*work.v[219];
work.d[608] = work.v[608];
if (work.d[608] > 0)
work.d[608] = -settings.kkt_reg;
else
work.d[608] -= settings.kkt_reg;
work.d_inv[608] = 1/work.d[608];
work.L[513] = (work.KKT[1265])*work.d_inv[608];
work.v[608] = work.L[513]*work.d[608];
work.v[609] = 0-work.L[513]*work.v[608];
work.d[609] = work.v[609];
if (work.d[609] < 0)
work.d[609] = settings.kkt_reg;
else
work.d[609] += settings.kkt_reg;
work.d_inv[609] = 1/work.d[609];
work.L[515] = (work.KKT[1266])*work.d_inv[609];
work.L[517] = (work.KKT[1267])*work.d_inv[609];
work.v[220] = work.L[514]*work.d[220];
work.v[609] = work.L[515]*work.d[609];
work.v[610] = work.KKT[1268]-work.L[514]*work.v[220]-work.L[515]*work.v[609];
work.d[610] = work.v[610];
if (work.d[610] > 0)
work.d[610] = -settings.kkt_reg;
else
work.d[610] -= settings.kkt_reg;
work.d_inv[610] = 1/work.d[610];
work.L[518] = (-work.L[517]*work.v[609])*work.d_inv[610];
work.L[1455] = (work.KKT[1269])*work.d_inv[610];
work.v[221] = work.L[516]*work.d[221];
work.v[609] = work.L[517]*work.d[609];
work.v[610] = work.L[518]*work.d[610];
work.v[611] = work.KKT[1270]-work.L[516]*work.v[221]-work.L[517]*work.v[609]-work.L[518]*work.v[610];
work.d[611] = work.v[611];
if (work.d[611] > 0)
work.d[611] = -settings.kkt_reg;
else
work.d[611] -= settings.kkt_reg;
work.d_inv[611] = 1/work.d[611];
work.L[1456] = (work.KKT[1271]-work.L[1455]*work.v[610])*work.d_inv[611];
work.v[222] = work.L[519]*work.d[222];
work.v[612] = work.KKT[1272]-work.L[519]*work.v[222];
work.d[612] = work.v[612];
if (work.d[612] > 0)
work.d[612] = -settings.kkt_reg;
else
work.d[612] -= settings.kkt_reg;
work.d_inv[612] = 1/work.d[612];
work.L[520] = (work.KKT[1273])*work.d_inv[612];
work.v[612] = work.L[520]*work.d[612];
work.v[613] = 0-work.L[520]*work.v[612];
work.d[613] = work.v[613];
if (work.d[613] < 0)
work.d[613] = settings.kkt_reg;
else
work.d[613] += settings.kkt_reg;
work.d_inv[613] = 1/work.d[613];
work.L[522] = (work.KKT[1274])*work.d_inv[613];
work.L[524] = (work.KKT[1275])*work.d_inv[613];
work.v[223] = work.L[521]*work.d[223];
work.v[613] = work.L[522]*work.d[613];
work.v[614] = work.KKT[1276]-work.L[521]*work.v[223]-work.L[522]*work.v[613];
work.d[614] = work.v[614];
if (work.d[614] > 0)
work.d[614] = -settings.kkt_reg;
else
work.d[614] -= settings.kkt_reg;
work.d_inv[614] = 1/work.d[614];
work.L[525] = (-work.L[524]*work.v[613])*work.d_inv[614];
work.L[1536] = (work.KKT[1277])*work.d_inv[614];
work.v[224] = work.L[523]*work.d[224];
work.v[613] = work.L[524]*work.d[613];
work.v[614] = work.L[525]*work.d[614];
work.v[615] = work.KKT[1278]-work.L[523]*work.v[224]-work.L[524]*work.v[613]-work.L[525]*work.v[614];
work.d[615] = work.v[615];
if (work.d[615] > 0)
work.d[615] = -settings.kkt_reg;
else
work.d[615] -= settings.kkt_reg;
work.d_inv[615] = 1/work.d[615];
work.L[1537] = (work.KKT[1279]-work.L[1536]*work.v[614])*work.d_inv[615];
work.v[225] = work.L[526]*work.d[225];
work.v[616] = work.KKT[1280]-work.L[526]*work.v[225];
work.d[616] = work.v[616];
if (work.d[616] > 0)
work.d[616] = -settings.kkt_reg;
else
work.d[616] -= settings.kkt_reg;
work.d_inv[616] = 1/work.d[616];
work.L[527] = (work.KKT[1281])*work.d_inv[616];
work.v[616] = work.L[527]*work.d[616];
work.v[617] = 0-work.L[527]*work.v[616];
work.d[617] = work.v[617];
if (work.d[617] < 0)
work.d[617] = settings.kkt_reg;
else
work.d[617] += settings.kkt_reg;
work.d_inv[617] = 1/work.d[617];
work.L[529] = (work.KKT[1282])*work.d_inv[617];
work.L[531] = (work.KKT[1283])*work.d_inv[617];
work.v[226] = work.L[528]*work.d[226];
work.v[617] = work.L[529]*work.d[617];
work.v[618] = work.KKT[1284]-work.L[528]*work.v[226]-work.L[529]*work.v[617];
work.d[618] = work.v[618];
if (work.d[618] > 0)
work.d[618] = -settings.kkt_reg;
else
work.d[618] -= settings.kkt_reg;
work.d_inv[618] = 1/work.d[618];
work.L[532] = (-work.L[531]*work.v[617])*work.d_inv[618];
work.L[1558] = (work.KKT[1285])*work.d_inv[618];
work.v[227] = work.L[530]*work.d[227];
work.v[617] = work.L[531]*work.d[617];
work.v[618] = work.L[532]*work.d[618];
work.v[619] = work.KKT[1286]-work.L[530]*work.v[227]-work.L[531]*work.v[617]-work.L[532]*work.v[618];
work.d[619] = work.v[619];
if (work.d[619] > 0)
work.d[619] = -settings.kkt_reg;
else
work.d[619] -= settings.kkt_reg;
work.d_inv[619] = 1/work.d[619];
work.L[1559] = (work.KKT[1287]-work.L[1558]*work.v[618])*work.d_inv[619];
work.v[228] = work.L[533]*work.d[228];
work.v[620] = work.KKT[1288]-work.L[533]*work.v[228];
work.d[620] = work.v[620];
if (work.d[620] > 0)
work.d[620] = -settings.kkt_reg;
else
work.d[620] -= settings.kkt_reg;
work.d_inv[620] = 1/work.d[620];
work.L[534] = (work.KKT[1289])*work.d_inv[620];
work.v[620] = work.L[534]*work.d[620];
work.v[621] = 0-work.L[534]*work.v[620];
work.d[621] = work.v[621];
if (work.d[621] < 0)
work.d[621] = settings.kkt_reg;
else
work.d[621] += settings.kkt_reg;
work.d_inv[621] = 1/work.d[621];
work.L[536] = (work.KKT[1290])*work.d_inv[621];
work.L[538] = (work.KKT[1291])*work.d_inv[621];
work.v[229] = work.L[535]*work.d[229];
work.v[621] = work.L[536]*work.d[621];
work.v[622] = work.KKT[1292]-work.L[535]*work.v[229]-work.L[536]*work.v[621];
work.d[622] = work.v[622];
if (work.d[622] > 0)
work.d[622] = -settings.kkt_reg;
else
work.d[622] -= settings.kkt_reg;
work.d_inv[622] = 1/work.d[622];
work.L[539] = (-work.L[538]*work.v[621])*work.d_inv[622];
work.L[1498] = (work.KKT[1293])*work.d_inv[622];
work.v[230] = work.L[537]*work.d[230];
work.v[621] = work.L[538]*work.d[621];
work.v[622] = work.L[539]*work.d[622];
work.v[623] = work.KKT[1294]-work.L[537]*work.v[230]-work.L[538]*work.v[621]-work.L[539]*work.v[622];
work.d[623] = work.v[623];
if (work.d[623] > 0)
work.d[623] = -settings.kkt_reg;
else
work.d[623] -= settings.kkt_reg;
work.d_inv[623] = 1/work.d[623];
work.L[1499] = (work.KKT[1295]-work.L[1498]*work.v[622])*work.d_inv[623];
work.v[231] = work.L[540]*work.d[231];
work.v[624] = work.KKT[1296]-work.L[540]*work.v[231];
work.d[624] = work.v[624];
if (work.d[624] > 0)
work.d[624] = -settings.kkt_reg;
else
work.d[624] -= settings.kkt_reg;
work.d_inv[624] = 1/work.d[624];
work.L[541] = (work.KKT[1297])*work.d_inv[624];
work.v[624] = work.L[541]*work.d[624];
work.v[625] = 0-work.L[541]*work.v[624];
work.d[625] = work.v[625];
if (work.d[625] < 0)
work.d[625] = settings.kkt_reg;
else
work.d[625] += settings.kkt_reg;
work.d_inv[625] = 1/work.d[625];
work.L[543] = (work.KKT[1298])*work.d_inv[625];
work.L[545] = (work.KKT[1299])*work.d_inv[625];
work.v[232] = work.L[542]*work.d[232];
work.v[625] = work.L[543]*work.d[625];
work.v[626] = work.KKT[1300]-work.L[542]*work.v[232]-work.L[543]*work.v[625];
work.d[626] = work.v[626];
if (work.d[626] > 0)
work.d[626] = -settings.kkt_reg;
else
work.d[626] -= settings.kkt_reg;
work.d_inv[626] = 1/work.d[626];
work.L[546] = (-work.L[545]*work.v[625])*work.d_inv[626];
work.L[547] = (work.KKT[1301])*work.d_inv[626];
work.v[233] = work.L[544]*work.d[233];
work.v[625] = work.L[545]*work.d[625];
work.v[626] = work.L[546]*work.d[626];
work.v[627] = work.KKT[1302]-work.L[544]*work.v[233]-work.L[545]*work.v[625]-work.L[546]*work.v[626];
work.d[627] = work.v[627];
if (work.d[627] > 0)
work.d[627] = -settings.kkt_reg;
else
work.d[627] -= settings.kkt_reg;
work.d_inv[627] = 1/work.d[627];
work.L[548] = (work.KKT[1303]-work.L[547]*work.v[626])*work.d_inv[627];
work.v[626] = work.L[547]*work.d[626];
work.v[627] = work.L[548]*work.d[627];
work.v[628] = work.KKT[1304]-work.L[547]*work.v[626]-work.L[548]*work.v[627];
work.d[628] = work.v[628];
if (work.d[628] < 0)
work.d[628] = settings.kkt_reg;
else
work.d[628] += settings.kkt_reg;
work.d_inv[628] = 1/work.d[628];
work.L[746] = (work.KKT[1305])*work.d_inv[628];
work.v[234] = work.L[549]*work.d[234];
work.v[629] = work.KKT[1306]-work.L[549]*work.v[234];
work.d[629] = work.v[629];
if (work.d[629] > 0)
work.d[629] = -settings.kkt_reg;
else
work.d[629] -= settings.kkt_reg;
work.d_inv[629] = 1/work.d[629];
work.L[550] = (work.KKT[1307])*work.d_inv[629];
work.v[629] = work.L[550]*work.d[629];
work.v[630] = 0-work.L[550]*work.v[629];
work.d[630] = work.v[630];
if (work.d[630] < 0)
work.d[630] = settings.kkt_reg;
else
work.d[630] += settings.kkt_reg;
work.d_inv[630] = 1/work.d[630];
work.L[552] = (work.KKT[1308])*work.d_inv[630];
work.L[554] = (work.KKT[1309])*work.d_inv[630];
work.v[235] = work.L[551]*work.d[235];
work.v[630] = work.L[552]*work.d[630];
work.v[631] = work.KKT[1310]-work.L[551]*work.v[235]-work.L[552]*work.v[630];
work.d[631] = work.v[631];
if (work.d[631] > 0)
work.d[631] = -settings.kkt_reg;
else
work.d[631] -= settings.kkt_reg;
work.d_inv[631] = 1/work.d[631];
work.L[555] = (-work.L[554]*work.v[630])*work.d_inv[631];
work.L[790] = (work.KKT[1311])*work.d_inv[631];
work.v[236] = work.L[553]*work.d[236];
work.v[630] = work.L[554]*work.d[630];
work.v[631] = work.L[555]*work.d[631];
work.v[632] = work.KKT[1312]-work.L[553]*work.v[236]-work.L[554]*work.v[630]-work.L[555]*work.v[631];
work.d[632] = work.v[632];
if (work.d[632] > 0)
work.d[632] = -settings.kkt_reg;
else
work.d[632] -= settings.kkt_reg;
work.d_inv[632] = 1/work.d[632];
work.L[791] = (work.KKT[1313]-work.L[790]*work.v[631])*work.d_inv[632];
work.v[237] = work.L[556]*work.d[237];
work.v[633] = work.KKT[1314]-work.L[556]*work.v[237];
work.d[633] = work.v[633];
if (work.d[633] > 0)
work.d[633] = -settings.kkt_reg;
else
work.d[633] -= settings.kkt_reg;
work.d_inv[633] = 1/work.d[633];
work.L[557] = (work.KKT[1315])*work.d_inv[633];
work.v[633] = work.L[557]*work.d[633];
work.v[634] = 0-work.L[557]*work.v[633];
work.d[634] = work.v[634];
if (work.d[634] < 0)
work.d[634] = settings.kkt_reg;
else
work.d[634] += settings.kkt_reg;
work.d_inv[634] = 1/work.d[634];
work.L[559] = (work.KKT[1316])*work.d_inv[634];
work.L[561] = (work.KKT[1317])*work.d_inv[634];
work.v[238] = work.L[558]*work.d[238];
work.v[634] = work.L[559]*work.d[634];
work.v[635] = work.KKT[1318]-work.L[558]*work.v[238]-work.L[559]*work.v[634];
work.d[635] = work.v[635];
if (work.d[635] > 0)
work.d[635] = -settings.kkt_reg;
else
work.d[635] -= settings.kkt_reg;
work.d_inv[635] = 1/work.d[635];
work.L[562] = (-work.L[561]*work.v[634])*work.d_inv[635];
work.L[799] = (work.KKT[1319])*work.d_inv[635];
work.v[239] = work.L[560]*work.d[239];
work.v[634] = work.L[561]*work.d[634];
work.v[635] = work.L[562]*work.d[635];
work.v[636] = work.KKT[1320]-work.L[560]*work.v[239]-work.L[561]*work.v[634]-work.L[562]*work.v[635];
work.d[636] = work.v[636];
if (work.d[636] > 0)
work.d[636] = -settings.kkt_reg;
else
work.d[636] -= settings.kkt_reg;
work.d_inv[636] = 1/work.d[636];
work.L[800] = (work.KKT[1321]-work.L[799]*work.v[635])*work.d_inv[636];
work.v[240] = work.L[563]*work.d[240];
work.v[637] = work.KKT[1322]-work.L[563]*work.v[240];
work.d[637] = work.v[637];
if (work.d[637] > 0)
work.d[637] = -settings.kkt_reg;
else
work.d[637] -= settings.kkt_reg;
work.d_inv[637] = 1/work.d[637];
work.L[564] = (work.KKT[1323])*work.d_inv[637];
work.v[637] = work.L[564]*work.d[637];
work.v[638] = 0-work.L[564]*work.v[637];
work.d[638] = work.v[638];
if (work.d[638] < 0)
work.d[638] = settings.kkt_reg;
else
work.d[638] += settings.kkt_reg;
work.d_inv[638] = 1/work.d[638];
work.L[566] = (work.KKT[1324])*work.d_inv[638];
work.L[568] = (work.KKT[1325])*work.d_inv[638];
work.v[241] = work.L[565]*work.d[241];
work.v[638] = work.L[566]*work.d[638];
work.v[639] = work.KKT[1326]-work.L[565]*work.v[241]-work.L[566]*work.v[638];
work.d[639] = work.v[639];
if (work.d[639] > 0)
work.d[639] = -settings.kkt_reg;
else
work.d[639] -= settings.kkt_reg;
work.d_inv[639] = 1/work.d[639];
work.L[569] = (-work.L[568]*work.v[638])*work.d_inv[639];
work.L[833] = (work.KKT[1327])*work.d_inv[639];
work.v[242] = work.L[567]*work.d[242];
work.v[638] = work.L[568]*work.d[638];
work.v[639] = work.L[569]*work.d[639];
work.v[640] = work.KKT[1328]-work.L[567]*work.v[242]-work.L[568]*work.v[638]-work.L[569]*work.v[639];
work.d[640] = work.v[640];
if (work.d[640] > 0)
work.d[640] = -settings.kkt_reg;
else
work.d[640] -= settings.kkt_reg;
work.d_inv[640] = 1/work.d[640];
work.L[834] = (work.KKT[1329]-work.L[833]*work.v[639])*work.d_inv[640];
work.v[243] = work.L[570]*work.d[243];
work.v[641] = work.KKT[1330]-work.L[570]*work.v[243];
work.d[641] = work.v[641];
if (work.d[641] > 0)
work.d[641] = -settings.kkt_reg;
else
work.d[641] -= settings.kkt_reg;
work.d_inv[641] = 1/work.d[641];
work.L[571] = (work.KKT[1331])*work.d_inv[641];
work.v[641] = work.L[571]*work.d[641];
work.v[642] = 0-work.L[571]*work.v[641];
work.d[642] = work.v[642];
if (work.d[642] < 0)
work.d[642] = settings.kkt_reg;
else
work.d[642] += settings.kkt_reg;
work.d_inv[642] = 1/work.d[642];
work.L[573] = (work.KKT[1332])*work.d_inv[642];
work.L[575] = (work.KKT[1333])*work.d_inv[642];
work.v[244] = work.L[572]*work.d[244];
work.v[642] = work.L[573]*work.d[642];
work.v[643] = work.KKT[1334]-work.L[572]*work.v[244]-work.L[573]*work.v[642];
work.d[643] = work.v[643];
if (work.d[643] > 0)
work.d[643] = -settings.kkt_reg;
else
work.d[643] -= settings.kkt_reg;
work.d_inv[643] = 1/work.d[643];
work.L[576] = (-work.L[575]*work.v[642])*work.d_inv[643];
work.L[868] = (work.KKT[1335])*work.d_inv[643];
work.v[245] = work.L[574]*work.d[245];
work.v[642] = work.L[575]*work.d[642];
work.v[643] = work.L[576]*work.d[643];
work.v[644] = work.KKT[1336]-work.L[574]*work.v[245]-work.L[575]*work.v[642]-work.L[576]*work.v[643];
work.d[644] = work.v[644];
if (work.d[644] > 0)
work.d[644] = -settings.kkt_reg;
else
work.d[644] -= settings.kkt_reg;
work.d_inv[644] = 1/work.d[644];
work.L[869] = (work.KKT[1337]-work.L[868]*work.v[643])*work.d_inv[644];
work.v[246] = work.L[577]*work.d[246];
work.v[645] = work.KKT[1338]-work.L[577]*work.v[246];
work.d[645] = work.v[645];
if (work.d[645] > 0)
work.d[645] = -settings.kkt_reg;
else
work.d[645] -= settings.kkt_reg;
work.d_inv[645] = 1/work.d[645];
work.L[578] = (work.KKT[1339])*work.d_inv[645];
work.v[645] = work.L[578]*work.d[645];
work.v[646] = 0-work.L[578]*work.v[645];
work.d[646] = work.v[646];
if (work.d[646] < 0)
work.d[646] = settings.kkt_reg;
else
work.d[646] += settings.kkt_reg;
work.d_inv[646] = 1/work.d[646];
work.L[580] = (work.KKT[1340])*work.d_inv[646];
work.L[582] = (work.KKT[1341])*work.d_inv[646];
work.v[247] = work.L[579]*work.d[247];
work.v[646] = work.L[580]*work.d[646];
work.v[647] = work.KKT[1342]-work.L[579]*work.v[247]-work.L[580]*work.v[646];
work.d[647] = work.v[647];
if (work.d[647] > 0)
work.d[647] = -settings.kkt_reg;
else
work.d[647] -= settings.kkt_reg;
work.d_inv[647] = 1/work.d[647];
work.L[583] = (-work.L[582]*work.v[646])*work.d_inv[647];
work.L[902] = (work.KKT[1343])*work.d_inv[647];
work.v[248] = work.L[581]*work.d[248];
work.v[646] = work.L[582]*work.d[646];
work.v[647] = work.L[583]*work.d[647];
work.v[648] = work.KKT[1344]-work.L[581]*work.v[248]-work.L[582]*work.v[646]-work.L[583]*work.v[647];
work.d[648] = work.v[648];
if (work.d[648] > 0)
work.d[648] = -settings.kkt_reg;
else
work.d[648] -= settings.kkt_reg;
work.d_inv[648] = 1/work.d[648];
work.L[903] = (work.KKT[1345]-work.L[902]*work.v[647])*work.d_inv[648];
work.v[249] = work.L[584]*work.d[249];
work.v[649] = work.KKT[1346]-work.L[584]*work.v[249];
work.d[649] = work.v[649];
if (work.d[649] > 0)
work.d[649] = -settings.kkt_reg;
else
work.d[649] -= settings.kkt_reg;
work.d_inv[649] = 1/work.d[649];
work.L[585] = (work.KKT[1347])*work.d_inv[649];
work.v[649] = work.L[585]*work.d[649];
work.v[650] = 0-work.L[585]*work.v[649];
work.d[650] = work.v[650];
if (work.d[650] < 0)
work.d[650] = settings.kkt_reg;
else
work.d[650] += settings.kkt_reg;
work.d_inv[650] = 1/work.d[650];
work.L[587] = (work.KKT[1348])*work.d_inv[650];
work.L[589] = (work.KKT[1349])*work.d_inv[650];
work.v[250] = work.L[586]*work.d[250];
work.v[650] = work.L[587]*work.d[650];
work.v[651] = work.KKT[1350]-work.L[586]*work.v[250]-work.L[587]*work.v[650];
work.d[651] = work.v[651];
if (work.d[651] > 0)
work.d[651] = -settings.kkt_reg;
else
work.d[651] -= settings.kkt_reg;
work.d_inv[651] = 1/work.d[651];
work.L[590] = (-work.L[589]*work.v[650])*work.d_inv[651];
work.L[936] = (work.KKT[1351])*work.d_inv[651];
work.v[251] = work.L[588]*work.d[251];
work.v[650] = work.L[589]*work.d[650];
work.v[651] = work.L[590]*work.d[651];
work.v[652] = work.KKT[1352]-work.L[588]*work.v[251]-work.L[589]*work.v[650]-work.L[590]*work.v[651];
work.d[652] = work.v[652];
if (work.d[652] > 0)
work.d[652] = -settings.kkt_reg;
else
work.d[652] -= settings.kkt_reg;
work.d_inv[652] = 1/work.d[652];
work.L[937] = (work.KKT[1353]-work.L[936]*work.v[651])*work.d_inv[652];
work.v[252] = work.L[591]*work.d[252];
work.v[653] = work.KKT[1354]-work.L[591]*work.v[252];
work.d[653] = work.v[653];
if (work.d[653] > 0)
work.d[653] = -settings.kkt_reg;
else
work.d[653] -= settings.kkt_reg;
work.d_inv[653] = 1/work.d[653];
work.L[592] = (work.KKT[1355])*work.d_inv[653];
work.v[653] = work.L[592]*work.d[653];
work.v[654] = 0-work.L[592]*work.v[653];
work.d[654] = work.v[654];
if (work.d[654] < 0)
work.d[654] = settings.kkt_reg;
else
work.d[654] += settings.kkt_reg;
work.d_inv[654] = 1/work.d[654];
work.L[594] = (work.KKT[1356])*work.d_inv[654];
work.L[596] = (work.KKT[1357])*work.d_inv[654];
work.v[253] = work.L[593]*work.d[253];
work.v[654] = work.L[594]*work.d[654];
work.v[655] = work.KKT[1358]-work.L[593]*work.v[253]-work.L[594]*work.v[654];
work.d[655] = work.v[655];
if (work.d[655] > 0)
work.d[655] = -settings.kkt_reg;
else
work.d[655] -= settings.kkt_reg;
work.d_inv[655] = 1/work.d[655];
work.L[597] = (-work.L[596]*work.v[654])*work.d_inv[655];
work.L[970] = (work.KKT[1359])*work.d_inv[655];
work.v[254] = work.L[595]*work.d[254];
work.v[654] = work.L[596]*work.d[654];
work.v[655] = work.L[597]*work.d[655];
work.v[656] = work.KKT[1360]-work.L[595]*work.v[254]-work.L[596]*work.v[654]-work.L[597]*work.v[655];
work.d[656] = work.v[656];
if (work.d[656] > 0)
work.d[656] = -settings.kkt_reg;
else
work.d[656] -= settings.kkt_reg;
work.d_inv[656] = 1/work.d[656];
work.L[971] = (work.KKT[1361]-work.L[970]*work.v[655])*work.d_inv[656];
work.v[255] = work.L[598]*work.d[255];
work.v[657] = work.KKT[1362]-work.L[598]*work.v[255];
work.d[657] = work.v[657];
if (work.d[657] > 0)
work.d[657] = -settings.kkt_reg;
else
work.d[657] -= settings.kkt_reg;
work.d_inv[657] = 1/work.d[657];
work.L[599] = (work.KKT[1363])*work.d_inv[657];
work.v[657] = work.L[599]*work.d[657];
work.v[658] = 0-work.L[599]*work.v[657];
work.d[658] = work.v[658];
if (work.d[658] < 0)
work.d[658] = settings.kkt_reg;
else
work.d[658] += settings.kkt_reg;
work.d_inv[658] = 1/work.d[658];
work.L[601] = (work.KKT[1364])*work.d_inv[658];
work.L[603] = (work.KKT[1365])*work.d_inv[658];
work.v[256] = work.L[600]*work.d[256];
work.v[658] = work.L[601]*work.d[658];
work.v[659] = work.KKT[1366]-work.L[600]*work.v[256]-work.L[601]*work.v[658];
work.d[659] = work.v[659];
if (work.d[659] > 0)
work.d[659] = -settings.kkt_reg;
else
work.d[659] -= settings.kkt_reg;
work.d_inv[659] = 1/work.d[659];
work.L[604] = (-work.L[603]*work.v[658])*work.d_inv[659];
work.L[1004] = (work.KKT[1367])*work.d_inv[659];
work.v[257] = work.L[602]*work.d[257];
work.v[658] = work.L[603]*work.d[658];
work.v[659] = work.L[604]*work.d[659];
work.v[660] = work.KKT[1368]-work.L[602]*work.v[257]-work.L[603]*work.v[658]-work.L[604]*work.v[659];
work.d[660] = work.v[660];
if (work.d[660] > 0)
work.d[660] = -settings.kkt_reg;
else
work.d[660] -= settings.kkt_reg;
work.d_inv[660] = 1/work.d[660];
work.L[1005] = (work.KKT[1369]-work.L[1004]*work.v[659])*work.d_inv[660];
work.v[258] = work.L[605]*work.d[258];
work.v[661] = work.KKT[1370]-work.L[605]*work.v[258];
work.d[661] = work.v[661];
if (work.d[661] > 0)
work.d[661] = -settings.kkt_reg;
else
work.d[661] -= settings.kkt_reg;
work.d_inv[661] = 1/work.d[661];
work.L[606] = (work.KKT[1371])*work.d_inv[661];
work.v[661] = work.L[606]*work.d[661];
work.v[662] = 0-work.L[606]*work.v[661];
work.d[662] = work.v[662];
if (work.d[662] < 0)
work.d[662] = settings.kkt_reg;
else
work.d[662] += settings.kkt_reg;
work.d_inv[662] = 1/work.d[662];
work.L[608] = (work.KKT[1372])*work.d_inv[662];
work.L[610] = (work.KKT[1373])*work.d_inv[662];
work.v[259] = work.L[607]*work.d[259];
work.v[662] = work.L[608]*work.d[662];
work.v[663] = work.KKT[1374]-work.L[607]*work.v[259]-work.L[608]*work.v[662];
work.d[663] = work.v[663];
if (work.d[663] > 0)
work.d[663] = -settings.kkt_reg;
else
work.d[663] -= settings.kkt_reg;
work.d_inv[663] = 1/work.d[663];
work.L[611] = (-work.L[610]*work.v[662])*work.d_inv[663];
work.L[1038] = (work.KKT[1375])*work.d_inv[663];
work.v[260] = work.L[609]*work.d[260];
work.v[662] = work.L[610]*work.d[662];
work.v[663] = work.L[611]*work.d[663];
work.v[664] = work.KKT[1376]-work.L[609]*work.v[260]-work.L[610]*work.v[662]-work.L[611]*work.v[663];
work.d[664] = work.v[664];
if (work.d[664] > 0)
work.d[664] = -settings.kkt_reg;
else
work.d[664] -= settings.kkt_reg;
work.d_inv[664] = 1/work.d[664];
work.L[1039] = (work.KKT[1377]-work.L[1038]*work.v[663])*work.d_inv[664];
work.v[261] = work.L[612]*work.d[261];
work.v[665] = work.KKT[1378]-work.L[612]*work.v[261];
work.d[665] = work.v[665];
if (work.d[665] > 0)
work.d[665] = -settings.kkt_reg;
else
work.d[665] -= settings.kkt_reg;
work.d_inv[665] = 1/work.d[665];
work.L[613] = (work.KKT[1379])*work.d_inv[665];
work.v[665] = work.L[613]*work.d[665];
work.v[666] = 0-work.L[613]*work.v[665];
work.d[666] = work.v[666];
if (work.d[666] < 0)
work.d[666] = settings.kkt_reg;
else
work.d[666] += settings.kkt_reg;
work.d_inv[666] = 1/work.d[666];
work.L[615] = (work.KKT[1380])*work.d_inv[666];
work.L[617] = (work.KKT[1381])*work.d_inv[666];
work.v[262] = work.L[614]*work.d[262];
work.v[666] = work.L[615]*work.d[666];
work.v[667] = work.KKT[1382]-work.L[614]*work.v[262]-work.L[615]*work.v[666];
work.d[667] = work.v[667];
if (work.d[667] > 0)
work.d[667] = -settings.kkt_reg;
else
work.d[667] -= settings.kkt_reg;
work.d_inv[667] = 1/work.d[667];
work.L[618] = (-work.L[617]*work.v[666])*work.d_inv[667];
work.L[1072] = (work.KKT[1383])*work.d_inv[667];
work.v[263] = work.L[616]*work.d[263];
work.v[666] = work.L[617]*work.d[666];
work.v[667] = work.L[618]*work.d[667];
work.v[668] = work.KKT[1384]-work.L[616]*work.v[263]-work.L[617]*work.v[666]-work.L[618]*work.v[667];
work.d[668] = work.v[668];
if (work.d[668] > 0)
work.d[668] = -settings.kkt_reg;
else
work.d[668] -= settings.kkt_reg;
work.d_inv[668] = 1/work.d[668];
work.L[1073] = (work.KKT[1385]-work.L[1072]*work.v[667])*work.d_inv[668];
work.v[264] = work.L[619]*work.d[264];
work.v[669] = work.KKT[1386]-work.L[619]*work.v[264];
work.d[669] = work.v[669];
if (work.d[669] > 0)
work.d[669] = -settings.kkt_reg;
else
work.d[669] -= settings.kkt_reg;
work.d_inv[669] = 1/work.d[669];
work.L[620] = (work.KKT[1387])*work.d_inv[669];
work.v[669] = work.L[620]*work.d[669];
work.v[670] = 0-work.L[620]*work.v[669];
work.d[670] = work.v[670];
if (work.d[670] < 0)
work.d[670] = settings.kkt_reg;
else
work.d[670] += settings.kkt_reg;
work.d_inv[670] = 1/work.d[670];
work.L[622] = (work.KKT[1388])*work.d_inv[670];
work.L[624] = (work.KKT[1389])*work.d_inv[670];
work.v[265] = work.L[621]*work.d[265];
work.v[670] = work.L[622]*work.d[670];
work.v[671] = work.KKT[1390]-work.L[621]*work.v[265]-work.L[622]*work.v[670];
work.d[671] = work.v[671];
if (work.d[671] > 0)
work.d[671] = -settings.kkt_reg;
else
work.d[671] -= settings.kkt_reg;
work.d_inv[671] = 1/work.d[671];
work.L[625] = (-work.L[624]*work.v[670])*work.d_inv[671];
work.L[1106] = (work.KKT[1391])*work.d_inv[671];
work.v[266] = work.L[623]*work.d[266];
work.v[670] = work.L[624]*work.d[670];
work.v[671] = work.L[625]*work.d[671];
work.v[672] = work.KKT[1392]-work.L[623]*work.v[266]-work.L[624]*work.v[670]-work.L[625]*work.v[671];
work.d[672] = work.v[672];
if (work.d[672] > 0)
work.d[672] = -settings.kkt_reg;
else
work.d[672] -= settings.kkt_reg;
work.d_inv[672] = 1/work.d[672];
work.L[1107] = (work.KKT[1393]-work.L[1106]*work.v[671])*work.d_inv[672];
work.v[267] = work.L[626]*work.d[267];
work.v[673] = work.KKT[1394]-work.L[626]*work.v[267];
work.d[673] = work.v[673];
if (work.d[673] > 0)
work.d[673] = -settings.kkt_reg;
else
work.d[673] -= settings.kkt_reg;
work.d_inv[673] = 1/work.d[673];
work.L[627] = (work.KKT[1395])*work.d_inv[673];
work.v[673] = work.L[627]*work.d[673];
work.v[674] = 0-work.L[627]*work.v[673];
work.d[674] = work.v[674];
if (work.d[674] < 0)
work.d[674] = settings.kkt_reg;
else
work.d[674] += settings.kkt_reg;
work.d_inv[674] = 1/work.d[674];
work.L[629] = (work.KKT[1396])*work.d_inv[674];
work.L[631] = (work.KKT[1397])*work.d_inv[674];
work.v[268] = work.L[628]*work.d[268];
work.v[674] = work.L[629]*work.d[674];
work.v[675] = work.KKT[1398]-work.L[628]*work.v[268]-work.L[629]*work.v[674];
work.d[675] = work.v[675];
if (work.d[675] > 0)
work.d[675] = -settings.kkt_reg;
else
work.d[675] -= settings.kkt_reg;
work.d_inv[675] = 1/work.d[675];
work.L[632] = (-work.L[631]*work.v[674])*work.d_inv[675];
work.L[1140] = (work.KKT[1399])*work.d_inv[675];
work.v[269] = work.L[630]*work.d[269];
work.v[674] = work.L[631]*work.d[674];
work.v[675] = work.L[632]*work.d[675];
work.v[676] = work.KKT[1400]-work.L[630]*work.v[269]-work.L[631]*work.v[674]-work.L[632]*work.v[675];
work.d[676] = work.v[676];
if (work.d[676] > 0)
work.d[676] = -settings.kkt_reg;
else
work.d[676] -= settings.kkt_reg;
work.d_inv[676] = 1/work.d[676];
work.L[1141] = (work.KKT[1401]-work.L[1140]*work.v[675])*work.d_inv[676];
work.v[270] = work.L[633]*work.d[270];
work.v[677] = work.KKT[1402]-work.L[633]*work.v[270];
work.d[677] = work.v[677];
if (work.d[677] > 0)
work.d[677] = -settings.kkt_reg;
else
work.d[677] -= settings.kkt_reg;
work.d_inv[677] = 1/work.d[677];
work.L[634] = (work.KKT[1403])*work.d_inv[677];
work.v[677] = work.L[634]*work.d[677];
work.v[678] = 0-work.L[634]*work.v[677];
work.d[678] = work.v[678];
if (work.d[678] < 0)
work.d[678] = settings.kkt_reg;
else
work.d[678] += settings.kkt_reg;
work.d_inv[678] = 1/work.d[678];
work.L[636] = (work.KKT[1404])*work.d_inv[678];
work.L[638] = (work.KKT[1405])*work.d_inv[678];
work.v[271] = work.L[635]*work.d[271];
work.v[678] = work.L[636]*work.d[678];
work.v[679] = work.KKT[1406]-work.L[635]*work.v[271]-work.L[636]*work.v[678];
work.d[679] = work.v[679];
if (work.d[679] > 0)
work.d[679] = -settings.kkt_reg;
else
work.d[679] -= settings.kkt_reg;
work.d_inv[679] = 1/work.d[679];
work.L[639] = (-work.L[638]*work.v[678])*work.d_inv[679];
work.L[1174] = (work.KKT[1407])*work.d_inv[679];
work.v[272] = work.L[637]*work.d[272];
work.v[678] = work.L[638]*work.d[678];
work.v[679] = work.L[639]*work.d[679];
work.v[680] = work.KKT[1408]-work.L[637]*work.v[272]-work.L[638]*work.v[678]-work.L[639]*work.v[679];
work.d[680] = work.v[680];
if (work.d[680] > 0)
work.d[680] = -settings.kkt_reg;
else
work.d[680] -= settings.kkt_reg;
work.d_inv[680] = 1/work.d[680];
work.L[1175] = (work.KKT[1409]-work.L[1174]*work.v[679])*work.d_inv[680];
work.v[273] = work.L[640]*work.d[273];
work.v[681] = work.KKT[1410]-work.L[640]*work.v[273];
work.d[681] = work.v[681];
if (work.d[681] > 0)
work.d[681] = -settings.kkt_reg;
else
work.d[681] -= settings.kkt_reg;
work.d_inv[681] = 1/work.d[681];
work.L[641] = (work.KKT[1411])*work.d_inv[681];
work.v[681] = work.L[641]*work.d[681];
work.v[682] = 0-work.L[641]*work.v[681];
work.d[682] = work.v[682];
if (work.d[682] < 0)
work.d[682] = settings.kkt_reg;
else
work.d[682] += settings.kkt_reg;
work.d_inv[682] = 1/work.d[682];
work.L[643] = (work.KKT[1412])*work.d_inv[682];
work.L[645] = (work.KKT[1413])*work.d_inv[682];
work.v[274] = work.L[642]*work.d[274];
work.v[682] = work.L[643]*work.d[682];
work.v[683] = work.KKT[1414]-work.L[642]*work.v[274]-work.L[643]*work.v[682];
work.d[683] = work.v[683];
if (work.d[683] > 0)
work.d[683] = -settings.kkt_reg;
else
work.d[683] -= settings.kkt_reg;
work.d_inv[683] = 1/work.d[683];
work.L[646] = (-work.L[645]*work.v[682])*work.d_inv[683];
work.L[1208] = (work.KKT[1415])*work.d_inv[683];
work.v[275] = work.L[644]*work.d[275];
work.v[682] = work.L[645]*work.d[682];
work.v[683] = work.L[646]*work.d[683];
work.v[684] = work.KKT[1416]-work.L[644]*work.v[275]-work.L[645]*work.v[682]-work.L[646]*work.v[683];
work.d[684] = work.v[684];
if (work.d[684] > 0)
work.d[684] = -settings.kkt_reg;
else
work.d[684] -= settings.kkt_reg;
work.d_inv[684] = 1/work.d[684];
work.L[1209] = (work.KKT[1417]-work.L[1208]*work.v[683])*work.d_inv[684];
work.v[276] = work.L[647]*work.d[276];
work.v[685] = work.KKT[1418]-work.L[647]*work.v[276];
work.d[685] = work.v[685];
if (work.d[685] > 0)
work.d[685] = -settings.kkt_reg;
else
work.d[685] -= settings.kkt_reg;
work.d_inv[685] = 1/work.d[685];
work.L[648] = (work.KKT[1419])*work.d_inv[685];
work.v[685] = work.L[648]*work.d[685];
work.v[686] = 0-work.L[648]*work.v[685];
work.d[686] = work.v[686];
if (work.d[686] < 0)
work.d[686] = settings.kkt_reg;
else
work.d[686] += settings.kkt_reg;
work.d_inv[686] = 1/work.d[686];
work.L[650] = (work.KKT[1420])*work.d_inv[686];
work.L[652] = (work.KKT[1421])*work.d_inv[686];
work.v[277] = work.L[649]*work.d[277];
work.v[686] = work.L[650]*work.d[686];
work.v[687] = work.KKT[1422]-work.L[649]*work.v[277]-work.L[650]*work.v[686];
work.d[687] = work.v[687];
if (work.d[687] > 0)
work.d[687] = -settings.kkt_reg;
else
work.d[687] -= settings.kkt_reg;
work.d_inv[687] = 1/work.d[687];
work.L[653] = (-work.L[652]*work.v[686])*work.d_inv[687];
work.L[1242] = (work.KKT[1423])*work.d_inv[687];
work.v[278] = work.L[651]*work.d[278];
work.v[686] = work.L[652]*work.d[686];
work.v[687] = work.L[653]*work.d[687];
work.v[688] = work.KKT[1424]-work.L[651]*work.v[278]-work.L[652]*work.v[686]-work.L[653]*work.v[687];
work.d[688] = work.v[688];
if (work.d[688] > 0)
work.d[688] = -settings.kkt_reg;
else
work.d[688] -= settings.kkt_reg;
work.d_inv[688] = 1/work.d[688];
work.L[1243] = (work.KKT[1425]-work.L[1242]*work.v[687])*work.d_inv[688];
work.v[279] = work.L[654]*work.d[279];
work.v[689] = work.KKT[1426]-work.L[654]*work.v[279];
work.d[689] = work.v[689];
if (work.d[689] > 0)
work.d[689] = -settings.kkt_reg;
else
work.d[689] -= settings.kkt_reg;
work.d_inv[689] = 1/work.d[689];
work.L[655] = (work.KKT[1427])*work.d_inv[689];
work.v[689] = work.L[655]*work.d[689];
work.v[690] = 0-work.L[655]*work.v[689];
work.d[690] = work.v[690];
if (work.d[690] < 0)
work.d[690] = settings.kkt_reg;
else
work.d[690] += settings.kkt_reg;
work.d_inv[690] = 1/work.d[690];
work.L[657] = (work.KKT[1428])*work.d_inv[690];
work.L[659] = (work.KKT[1429])*work.d_inv[690];
work.v[280] = work.L[656]*work.d[280];
work.v[690] = work.L[657]*work.d[690];
work.v[691] = work.KKT[1430]-work.L[656]*work.v[280]-work.L[657]*work.v[690];
work.d[691] = work.v[691];
if (work.d[691] > 0)
work.d[691] = -settings.kkt_reg;
else
work.d[691] -= settings.kkt_reg;
work.d_inv[691] = 1/work.d[691];
work.L[660] = (-work.L[659]*work.v[690])*work.d_inv[691];
work.L[1276] = (work.KKT[1431])*work.d_inv[691];
work.v[281] = work.L[658]*work.d[281];
work.v[690] = work.L[659]*work.d[690];
work.v[691] = work.L[660]*work.d[691];
work.v[692] = work.KKT[1432]-work.L[658]*work.v[281]-work.L[659]*work.v[690]-work.L[660]*work.v[691];
work.d[692] = work.v[692];
if (work.d[692] > 0)
work.d[692] = -settings.kkt_reg;
else
work.d[692] -= settings.kkt_reg;
work.d_inv[692] = 1/work.d[692];
work.L[1277] = (work.KKT[1433]-work.L[1276]*work.v[691])*work.d_inv[692];
work.v[282] = work.L[661]*work.d[282];
work.v[693] = work.KKT[1434]-work.L[661]*work.v[282];
work.d[693] = work.v[693];
if (work.d[693] > 0)
work.d[693] = -settings.kkt_reg;
else
work.d[693] -= settings.kkt_reg;
work.d_inv[693] = 1/work.d[693];
work.L[662] = (work.KKT[1435])*work.d_inv[693];
work.v[693] = work.L[662]*work.d[693];
work.v[694] = 0-work.L[662]*work.v[693];
work.d[694] = work.v[694];
if (work.d[694] < 0)
work.d[694] = settings.kkt_reg;
else
work.d[694] += settings.kkt_reg;
work.d_inv[694] = 1/work.d[694];
work.L[664] = (work.KKT[1436])*work.d_inv[694];
work.L[666] = (work.KKT[1437])*work.d_inv[694];
work.v[283] = work.L[663]*work.d[283];
work.v[694] = work.L[664]*work.d[694];
work.v[695] = work.KKT[1438]-work.L[663]*work.v[283]-work.L[664]*work.v[694];
work.d[695] = work.v[695];
if (work.d[695] > 0)
work.d[695] = -settings.kkt_reg;
else
work.d[695] -= settings.kkt_reg;
work.d_inv[695] = 1/work.d[695];
work.L[667] = (-work.L[666]*work.v[694])*work.d_inv[695];
work.L[1310] = (work.KKT[1439])*work.d_inv[695];
work.v[284] = work.L[665]*work.d[284];
work.v[694] = work.L[666]*work.d[694];
work.v[695] = work.L[667]*work.d[695];
work.v[696] = work.KKT[1440]-work.L[665]*work.v[284]-work.L[666]*work.v[694]-work.L[667]*work.v[695];
work.d[696] = work.v[696];
if (work.d[696] > 0)
work.d[696] = -settings.kkt_reg;
else
work.d[696] -= settings.kkt_reg;
work.d_inv[696] = 1/work.d[696];
work.L[1311] = (work.KKT[1441]-work.L[1310]*work.v[695])*work.d_inv[696];
work.v[285] = work.L[668]*work.d[285];
work.v[697] = work.KKT[1442]-work.L[668]*work.v[285];
work.d[697] = work.v[697];
if (work.d[697] > 0)
work.d[697] = -settings.kkt_reg;
else
work.d[697] -= settings.kkt_reg;
work.d_inv[697] = 1/work.d[697];
work.L[669] = (work.KKT[1443])*work.d_inv[697];
work.v[697] = work.L[669]*work.d[697];
work.v[698] = 0-work.L[669]*work.v[697];
work.d[698] = work.v[698];
if (work.d[698] < 0)
work.d[698] = settings.kkt_reg;
else
work.d[698] += settings.kkt_reg;
work.d_inv[698] = 1/work.d[698];
work.L[671] = (work.KKT[1444])*work.d_inv[698];
work.L[673] = (work.KKT[1445])*work.d_inv[698];
work.v[286] = work.L[670]*work.d[286];
work.v[698] = work.L[671]*work.d[698];
work.v[699] = work.KKT[1446]-work.L[670]*work.v[286]-work.L[671]*work.v[698];
work.d[699] = work.v[699];
if (work.d[699] > 0)
work.d[699] = -settings.kkt_reg;
else
work.d[699] -= settings.kkt_reg;
work.d_inv[699] = 1/work.d[699];
work.L[674] = (-work.L[673]*work.v[698])*work.d_inv[699];
work.L[1344] = (work.KKT[1447])*work.d_inv[699];
work.v[287] = work.L[672]*work.d[287];
work.v[698] = work.L[673]*work.d[698];
work.v[699] = work.L[674]*work.d[699];
work.v[700] = work.KKT[1448]-work.L[672]*work.v[287]-work.L[673]*work.v[698]-work.L[674]*work.v[699];
work.d[700] = work.v[700];
if (work.d[700] > 0)
work.d[700] = -settings.kkt_reg;
else
work.d[700] -= settings.kkt_reg;
work.d_inv[700] = 1/work.d[700];
work.L[1345] = (work.KKT[1449]-work.L[1344]*work.v[699])*work.d_inv[700];
work.v[288] = work.L[675]*work.d[288];
work.v[701] = work.KKT[1450]-work.L[675]*work.v[288];
work.d[701] = work.v[701];
if (work.d[701] > 0)
work.d[701] = -settings.kkt_reg;
else
work.d[701] -= settings.kkt_reg;
work.d_inv[701] = 1/work.d[701];
work.L[676] = (work.KKT[1451])*work.d_inv[701];
work.v[701] = work.L[676]*work.d[701];
work.v[702] = 0-work.L[676]*work.v[701];
work.d[702] = work.v[702];
if (work.d[702] < 0)
work.d[702] = settings.kkt_reg;
else
work.d[702] += settings.kkt_reg;
work.d_inv[702] = 1/work.d[702];
work.L[678] = (work.KKT[1452])*work.d_inv[702];
work.L[680] = (work.KKT[1453])*work.d_inv[702];
work.v[289] = work.L[677]*work.d[289];
work.v[702] = work.L[678]*work.d[702];
work.v[703] = work.KKT[1454]-work.L[677]*work.v[289]-work.L[678]*work.v[702];
work.d[703] = work.v[703];
if (work.d[703] > 0)
work.d[703] = -settings.kkt_reg;
else
work.d[703] -= settings.kkt_reg;
work.d_inv[703] = 1/work.d[703];
work.L[681] = (-work.L[680]*work.v[702])*work.d_inv[703];
work.L[1378] = (work.KKT[1455])*work.d_inv[703];
work.v[290] = work.L[679]*work.d[290];
work.v[702] = work.L[680]*work.d[702];
work.v[703] = work.L[681]*work.d[703];
work.v[704] = work.KKT[1456]-work.L[679]*work.v[290]-work.L[680]*work.v[702]-work.L[681]*work.v[703];
work.d[704] = work.v[704];
if (work.d[704] > 0)
work.d[704] = -settings.kkt_reg;
else
work.d[704] -= settings.kkt_reg;
work.d_inv[704] = 1/work.d[704];
work.L[1379] = (work.KKT[1457]-work.L[1378]*work.v[703])*work.d_inv[704];
work.v[291] = work.L[682]*work.d[291];
work.v[705] = work.KKT[1458]-work.L[682]*work.v[291];
work.d[705] = work.v[705];
if (work.d[705] > 0)
work.d[705] = -settings.kkt_reg;
else
work.d[705] -= settings.kkt_reg;
work.d_inv[705] = 1/work.d[705];
work.L[683] = (work.KKT[1459])*work.d_inv[705];
work.v[705] = work.L[683]*work.d[705];
work.v[706] = 0-work.L[683]*work.v[705];
work.d[706] = work.v[706];
if (work.d[706] < 0)
work.d[706] = settings.kkt_reg;
else
work.d[706] += settings.kkt_reg;
work.d_inv[706] = 1/work.d[706];
work.L[685] = (work.KKT[1460])*work.d_inv[706];
work.L[687] = (work.KKT[1461])*work.d_inv[706];
work.v[292] = work.L[684]*work.d[292];
work.v[706] = work.L[685]*work.d[706];
work.v[707] = work.KKT[1462]-work.L[684]*work.v[292]-work.L[685]*work.v[706];
work.d[707] = work.v[707];
if (work.d[707] > 0)
work.d[707] = -settings.kkt_reg;
else
work.d[707] -= settings.kkt_reg;
work.d_inv[707] = 1/work.d[707];
work.L[688] = (-work.L[687]*work.v[706])*work.d_inv[707];
work.L[1412] = (work.KKT[1463])*work.d_inv[707];
work.v[293] = work.L[686]*work.d[293];
work.v[706] = work.L[687]*work.d[706];
work.v[707] = work.L[688]*work.d[707];
work.v[708] = work.KKT[1464]-work.L[686]*work.v[293]-work.L[687]*work.v[706]-work.L[688]*work.v[707];
work.d[708] = work.v[708];
if (work.d[708] > 0)
work.d[708] = -settings.kkt_reg;
else
work.d[708] -= settings.kkt_reg;
work.d_inv[708] = 1/work.d[708];
work.L[1413] = (work.KKT[1465]-work.L[1412]*work.v[707])*work.d_inv[708];
work.v[294] = work.L[689]*work.d[294];
work.v[709] = work.KKT[1466]-work.L[689]*work.v[294];
work.d[709] = work.v[709];
if (work.d[709] > 0)
work.d[709] = -settings.kkt_reg;
else
work.d[709] -= settings.kkt_reg;
work.d_inv[709] = 1/work.d[709];
work.L[690] = (work.KKT[1467])*work.d_inv[709];
work.v[709] = work.L[690]*work.d[709];
work.v[710] = 0-work.L[690]*work.v[709];
work.d[710] = work.v[710];
if (work.d[710] < 0)
work.d[710] = settings.kkt_reg;
else
work.d[710] += settings.kkt_reg;
work.d_inv[710] = 1/work.d[710];
work.L[692] = (work.KKT[1468])*work.d_inv[710];
work.L[694] = (work.KKT[1469])*work.d_inv[710];
work.v[295] = work.L[691]*work.d[295];
work.v[710] = work.L[692]*work.d[710];
work.v[711] = work.KKT[1470]-work.L[691]*work.v[295]-work.L[692]*work.v[710];
work.d[711] = work.v[711];
if (work.d[711] > 0)
work.d[711] = -settings.kkt_reg;
else
work.d[711] -= settings.kkt_reg;
work.d_inv[711] = 1/work.d[711];
work.L[695] = (-work.L[694]*work.v[710])*work.d_inv[711];
work.L[1446] = (work.KKT[1471])*work.d_inv[711];
work.v[296] = work.L[693]*work.d[296];
work.v[710] = work.L[694]*work.d[710];
work.v[711] = work.L[695]*work.d[711];
work.v[712] = work.KKT[1472]-work.L[693]*work.v[296]-work.L[694]*work.v[710]-work.L[695]*work.v[711];
work.d[712] = work.v[712];
if (work.d[712] > 0)
work.d[712] = -settings.kkt_reg;
else
work.d[712] -= settings.kkt_reg;
work.d_inv[712] = 1/work.d[712];
work.L[1447] = (work.KKT[1473]-work.L[1446]*work.v[711])*work.d_inv[712];
work.v[297] = work.L[696]*work.d[297];
work.v[713] = work.KKT[1474]-work.L[696]*work.v[297];
work.d[713] = work.v[713];
if (work.d[713] > 0)
work.d[713] = -settings.kkt_reg;
else
work.d[713] -= settings.kkt_reg;
work.d_inv[713] = 1/work.d[713];
work.L[697] = (work.KKT[1475])*work.d_inv[713];
work.v[713] = work.L[697]*work.d[713];
work.v[714] = 0-work.L[697]*work.v[713];
work.d[714] = work.v[714];
if (work.d[714] < 0)
work.d[714] = settings.kkt_reg;
else
work.d[714] += settings.kkt_reg;
work.d_inv[714] = 1/work.d[714];
work.L[699] = (work.KKT[1476])*work.d_inv[714];
work.L[701] = (work.KKT[1477])*work.d_inv[714];
work.v[298] = work.L[698]*work.d[298];
work.v[714] = work.L[699]*work.d[714];
work.v[715] = work.KKT[1478]-work.L[698]*work.v[298]-work.L[699]*work.v[714];
work.d[715] = work.v[715];
if (work.d[715] > 0)
work.d[715] = -settings.kkt_reg;
else
work.d[715] -= settings.kkt_reg;
work.d_inv[715] = 1/work.d[715];
work.L[702] = (-work.L[701]*work.v[714])*work.d_inv[715];
work.L[1480] = (work.KKT[1479])*work.d_inv[715];
work.v[299] = work.L[700]*work.d[299];
work.v[714] = work.L[701]*work.d[714];
work.v[715] = work.L[702]*work.d[715];
work.v[716] = work.KKT[1480]-work.L[700]*work.v[299]-work.L[701]*work.v[714]-work.L[702]*work.v[715];
work.d[716] = work.v[716];
if (work.d[716] > 0)
work.d[716] = -settings.kkt_reg;
else
work.d[716] -= settings.kkt_reg;
work.d_inv[716] = 1/work.d[716];
work.L[1481] = (work.KKT[1481]-work.L[1480]*work.v[715])*work.d_inv[716];
work.v[300] = work.L[703]*work.d[300];
work.v[717] = work.KKT[1482]-work.L[703]*work.v[300];
work.d[717] = work.v[717];
if (work.d[717] > 0)
work.d[717] = -settings.kkt_reg;
else
work.d[717] -= settings.kkt_reg;
work.d_inv[717] = 1/work.d[717];
work.L[704] = (work.KKT[1483])*work.d_inv[717];
work.v[717] = work.L[704]*work.d[717];
work.v[718] = 0-work.L[704]*work.v[717];
work.d[718] = work.v[718];
if (work.d[718] < 0)
work.d[718] = settings.kkt_reg;
else
work.d[718] += settings.kkt_reg;
work.d_inv[718] = 1/work.d[718];
work.L[706] = (work.KKT[1484])*work.d_inv[718];
work.L[708] = (work.KKT[1485])*work.d_inv[718];
work.v[301] = work.L[705]*work.d[301];
work.v[718] = work.L[706]*work.d[718];
work.v[719] = work.KKT[1486]-work.L[705]*work.v[301]-work.L[706]*work.v[718];
work.d[719] = work.v[719];
if (work.d[719] > 0)
work.d[719] = -settings.kkt_reg;
else
work.d[719] -= settings.kkt_reg;
work.d_inv[719] = 1/work.d[719];
work.L[709] = (-work.L[708]*work.v[718])*work.d_inv[719];
work.L[1547] = (work.KKT[1487])*work.d_inv[719];
work.v[302] = work.L[707]*work.d[302];
work.v[718] = work.L[708]*work.d[718];
work.v[719] = work.L[709]*work.d[719];
work.v[720] = work.KKT[1488]-work.L[707]*work.v[302]-work.L[708]*work.v[718]-work.L[709]*work.v[719];
work.d[720] = work.v[720];
if (work.d[720] > 0)
work.d[720] = -settings.kkt_reg;
else
work.d[720] -= settings.kkt_reg;
work.d_inv[720] = 1/work.d[720];
work.L[1548] = (work.KKT[1489]-work.L[1547]*work.v[719])*work.d_inv[720];
work.v[303] = work.L[710]*work.d[303];
work.v[721] = work.KKT[1490]-work.L[710]*work.v[303];
work.d[721] = work.v[721];
if (work.d[721] > 0)
work.d[721] = -settings.kkt_reg;
else
work.d[721] -= settings.kkt_reg;
work.d_inv[721] = 1/work.d[721];
work.L[711] = (work.KKT[1491])*work.d_inv[721];
work.v[721] = work.L[711]*work.d[721];
work.v[722] = 0-work.L[711]*work.v[721];
work.d[722] = work.v[722];
if (work.d[722] < 0)
work.d[722] = settings.kkt_reg;
else
work.d[722] += settings.kkt_reg;
work.d_inv[722] = 1/work.d[722];
work.L[713] = (work.KKT[1492])*work.d_inv[722];
work.L[715] = (work.KKT[1493])*work.d_inv[722];
work.v[304] = work.L[712]*work.d[304];
work.v[722] = work.L[713]*work.d[722];
work.v[723] = work.KKT[1494]-work.L[712]*work.v[304]-work.L[713]*work.v[722];
work.d[723] = work.v[723];
if (work.d[723] > 0)
work.d[723] = -settings.kkt_reg;
else
work.d[723] -= settings.kkt_reg;
work.d_inv[723] = 1/work.d[723];
work.L[716] = (-work.L[715]*work.v[722])*work.d_inv[723];
work.L[1506] = (work.KKT[1495])*work.d_inv[723];
work.v[305] = work.L[714]*work.d[305];
work.v[722] = work.L[715]*work.d[722];
work.v[723] = work.L[716]*work.d[723];
work.v[724] = work.KKT[1496]-work.L[714]*work.v[305]-work.L[715]*work.v[722]-work.L[716]*work.v[723];
work.d[724] = work.v[724];
if (work.d[724] > 0)
work.d[724] = -settings.kkt_reg;
else
work.d[724] -= settings.kkt_reg;
work.d_inv[724] = 1/work.d[724];
work.L[1507] = (work.KKT[1497]-work.L[1506]*work.v[723])*work.d_inv[724];
work.v[306] = work.L[717]*work.d[306];
work.v[725] = work.KKT[1498]-work.L[717]*work.v[306];
work.d[725] = work.v[725];
if (work.d[725] > 0)
work.d[725] = -settings.kkt_reg;
else
work.d[725] -= settings.kkt_reg;
work.d_inv[725] = 1/work.d[725];
work.L[718] = (work.KKT[1499])*work.d_inv[725];
work.v[725] = work.L[718]*work.d[725];
work.v[726] = 0-work.L[718]*work.v[725];
work.d[726] = work.v[726];
if (work.d[726] < 0)
work.d[726] = settings.kkt_reg;
else
work.d[726] += settings.kkt_reg;
work.d_inv[726] = 1/work.d[726];
work.L[720] = (work.KKT[1500])*work.d_inv[726];
work.L[722] = (work.KKT[1501])*work.d_inv[726];
work.v[307] = work.L[719]*work.d[307];
work.v[726] = work.L[720]*work.d[726];
work.v[727] = work.KKT[1502]-work.L[719]*work.v[307]-work.L[720]*work.v[726];
work.d[727] = work.v[727];
if (work.d[727] > 0)
work.d[727] = -settings.kkt_reg;
else
work.d[727] -= settings.kkt_reg;
work.d_inv[727] = 1/work.d[727];
work.L[723] = (-work.L[722]*work.v[726])*work.d_inv[727];
work.L[778] = (work.KKT[1503])*work.d_inv[727];
work.v[308] = work.L[721]*work.d[308];
work.v[726] = work.L[722]*work.d[726];
work.v[727] = work.L[723]*work.d[727];
work.v[728] = work.KKT[1504]-work.L[721]*work.v[308]-work.L[722]*work.v[726]-work.L[723]*work.v[727];
work.d[728] = work.v[728];
if (work.d[728] > 0)
work.d[728] = -settings.kkt_reg;
else
work.d[728] -= settings.kkt_reg;
work.d_inv[728] = 1/work.d[728];
work.L[779] = (work.KKT[1505]-work.L[778]*work.v[727])*work.d_inv[728];
work.v[309] = work.L[724]*work.d[309];
work.v[729] = work.KKT[1506]-work.L[724]*work.v[309];
work.d[729] = work.v[729];
if (work.d[729] > 0)
work.d[729] = -settings.kkt_reg;
else
work.d[729] -= settings.kkt_reg;
work.d_inv[729] = 1/work.d[729];
work.L[725] = (work.KKT[1507])*work.d_inv[729];
work.v[729] = work.L[725]*work.d[729];
work.v[730] = 0-work.L[725]*work.v[729];
work.d[730] = work.v[730];
if (work.d[730] < 0)
work.d[730] = settings.kkt_reg;
else
work.d[730] += settings.kkt_reg;
work.d_inv[730] = 1/work.d[730];
work.L[727] = (work.KKT[1508])*work.d_inv[730];
work.L[729] = (work.KKT[1509])*work.d_inv[730];
work.v[310] = work.L[726]*work.d[310];
work.v[730] = work.L[727]*work.d[730];
work.v[731] = work.KKT[1510]-work.L[726]*work.v[310]-work.L[727]*work.v[730];
work.d[731] = work.v[731];
if (work.d[731] > 0)
work.d[731] = -settings.kkt_reg;
else
work.d[731] -= settings.kkt_reg;
work.d_inv[731] = 1/work.d[731];
work.L[730] = (-work.L[729]*work.v[730])*work.d_inv[731];
work.L[731] = (work.KKT[1511])*work.d_inv[731];
work.v[311] = work.L[728]*work.d[311];
work.v[730] = work.L[729]*work.d[730];
work.v[731] = work.L[730]*work.d[731];
work.v[732] = work.KKT[1512]-work.L[728]*work.v[311]-work.L[729]*work.v[730]-work.L[730]*work.v[731];
work.d[732] = work.v[732];
if (work.d[732] > 0)
work.d[732] = -settings.kkt_reg;
else
work.d[732] -= settings.kkt_reg;
work.d_inv[732] = 1/work.d[732];
work.L[732] = (work.KKT[1513]-work.L[731]*work.v[731])*work.d_inv[732];
work.v[731] = work.L[731]*work.d[731];
work.v[732] = work.L[732]*work.d[732];
work.v[733] = work.KKT[1514]-work.L[731]*work.v[731]-work.L[732]*work.v[732];
work.d[733] = work.v[733];
if (work.d[733] < 0)
work.d[733] = settings.kkt_reg;
else
work.d[733] += settings.kkt_reg;
work.d_inv[733] = 1/work.d[733];
work.L[747] = (work.KKT[1515])*work.d_inv[733];
work.v[418] = work.L[733]*work.d[418];
work.v[419] = work.L[734]*work.d[419];
work.v[522] = work.L[735]*work.d[522];
work.v[523] = work.L[736]*work.d[523];
work.v[734] = 0-work.L[733]*work.v[418]-work.L[734]*work.v[419]-work.L[735]*work.v[522]-work.L[736]*work.v[523];
work.d[734] = work.v[734];
if (work.d[734] < 0)
work.d[734] = settings.kkt_reg;
else
work.d[734] += settings.kkt_reg;
work.d_inv[734] = 1/work.d[734];
work.L[748] = (work.KKT[1516])*work.d_inv[734];
work.L[775] = (-work.L[773]*work.v[522]-work.L[774]*work.v[523])*work.d_inv[734];
work.v[735] = 0;
work.d[735] = work.v[735];
if (work.d[735] > 0)
work.d[735] = -settings.kkt_reg;
else
work.d[735] -= settings.kkt_reg;
work.d_inv[735] = 1/work.d[735];
work.L[743] = (work.KKT[1517])*work.d_inv[735];
work.L[792] = (work.KKT[1518])*work.d_inv[735];
work.v[318] = work.L[737]*work.d[318];
work.v[319] = work.L[738]*work.d[319];
work.v[422] = work.L[739]*work.d[422];
work.v[423] = work.L[740]*work.d[423];
work.v[426] = work.L[741]*work.d[426];
work.v[427] = work.L[742]*work.d[427];
work.v[735] = work.L[743]*work.d[735];
work.v[736] = 0-work.L[737]*work.v[318]-work.L[738]*work.v[319]-work.L[739]*work.v[422]-work.L[740]*work.v[423]-work.L[741]*work.v[426]-work.L[742]*work.v[427]-work.L[743]*work.v[735];
work.d[736] = work.v[736];
if (work.d[736] < 0)
work.d[736] = settings.kkt_reg;
else
work.d[736] += settings.kkt_reg;
work.d_inv[736] = 1/work.d[736];
work.L[764] = (-work.L[760]*work.v[426]-work.L[761]*work.v[427])*work.d_inv[736];
work.L[793] = (-work.L[792]*work.v[735])*work.d_inv[736];
work.v[314] = work.L[744]*work.d[314];
work.v[737] = 0-work.L[744]*work.v[314];
work.d[737] = work.v[737];
if (work.d[737] > 0)
work.d[737] = -settings.kkt_reg;
else
work.d[737] -= settings.kkt_reg;
work.d_inv[737] = 1/work.d[737];
work.L[752] = (work.KKT[1519])*work.d_inv[737];
work.L[753] = (work.KKT[1520])*work.d_inv[737];
work.v[315] = work.L[745]*work.d[315];
work.v[738] = 0-work.L[745]*work.v[315];
work.d[738] = work.v[738];
if (work.d[738] > 0)
work.d[738] = -settings.kkt_reg;
else
work.d[738] -= settings.kkt_reg;
work.d_inv[738] = 1/work.d[738];
work.L[755] = (work.KKT[1521])*work.d_inv[738];
work.L[1500] = (work.KKT[1522])*work.d_inv[738];
work.v[628] = work.L[746]*work.d[628];
work.v[739] = 0-work.L[746]*work.v[628];
work.d[739] = work.v[739];
if (work.d[739] > 0)
work.d[739] = -settings.kkt_reg;
else
work.d[739] -= settings.kkt_reg;
work.d_inv[739] = 1/work.d[739];
work.L[780] = (work.KKT[1523])*work.d_inv[739];
work.L[1501] = (work.KKT[1524])*work.d_inv[739];
work.v[733] = work.L[747]*work.d[733];
work.v[734] = work.L[748]*work.d[734];
work.v[740] = 0-work.L[747]*work.v[733]-work.L[748]*work.v[734];
work.d[740] = work.v[740];
if (work.d[740] > 0)
work.d[740] = -settings.kkt_reg;
else
work.d[740] -= settings.kkt_reg;
work.d_inv[740] = 1/work.d[740];
work.L[776] = (-work.L[775]*work.v[734])*work.d_inv[740];
work.L[781] = (work.KKT[1525])*work.d_inv[740];
work.v[313] = work.L[749]*work.d[313];
work.v[526] = work.L[750]*work.d[526];
work.v[527] = work.L[751]*work.d[527];
work.v[737] = work.L[752]*work.d[737];
work.v[741] = work.KKT[1526]-work.L[749]*work.v[313]-work.L[750]*work.v[526]-work.L[751]*work.v[527]-work.L[752]*work.v[737];
work.d[741] = work.v[741];
if (work.d[741] < 0)
work.d[741] = settings.kkt_reg;
else
work.d[741] += settings.kkt_reg;
work.d_inv[741] = 1/work.d[741];
work.L[754] = (-work.L[753]*work.v[737])*work.d_inv[741];
work.L[756] = (work.KKT[1527])*work.d_inv[741];
work.v[737] = work.L[753]*work.d[737];
work.v[741] = work.L[754]*work.d[741];
work.v[742] = work.KKT[1528]-work.L[753]*work.v[737]-work.L[754]*work.v[741];
work.d[742] = work.v[742];
if (work.d[742] < 0)
work.d[742] = settings.kkt_reg;
else
work.d[742] += settings.kkt_reg;
work.d_inv[742] = 1/work.d[742];
work.L[757] = (-work.L[756]*work.v[741])*work.d_inv[742];
work.L[766] = (work.KKT[1529])*work.d_inv[742];
work.v[743] = work.KKT[1530];
work.d[743] = work.v[743];
if (work.d[743] < 0)
work.d[743] = settings.kkt_reg;
else
work.d[743] += settings.kkt_reg;
work.d_inv[743] = 1/work.d[743];
work.L[767] = (work.KKT[1531])*work.d_inv[743];
work.L[812] = (work.KKT[1532])*work.d_inv[743];
work.v[744] = work.KKT[1533];
work.d[744] = work.v[744];
if (work.d[744] < 0)
work.d[744] = settings.kkt_reg;
else
work.d[744] += settings.kkt_reg;
work.d_inv[744] = 1/work.d[744];
work.L[813] = (work.KKT[1534])*work.d_inv[744];
work.L[851] = (work.KKT[1535])*work.d_inv[744];
work.v[745] = work.KKT[1536];
work.d[745] = work.v[745];
if (work.d[745] < 0)
work.d[745] = settings.kkt_reg;
else
work.d[745] += settings.kkt_reg;
work.d_inv[745] = 1/work.d[745];
work.L[852] = (work.KKT[1537])*work.d_inv[745];
work.L[885] = (work.KKT[1538])*work.d_inv[745];
work.v[746] = work.KKT[1539];
work.d[746] = work.v[746];
if (work.d[746] < 0)
work.d[746] = settings.kkt_reg;
else
work.d[746] += settings.kkt_reg;
work.d_inv[746] = 1/work.d[746];
work.L[886] = (work.KKT[1540])*work.d_inv[746];
work.L[919] = (work.KKT[1541])*work.d_inv[746];
work.v[747] = work.KKT[1542];
work.d[747] = work.v[747];
if (work.d[747] < 0)
work.d[747] = settings.kkt_reg;
else
work.d[747] += settings.kkt_reg;
work.d_inv[747] = 1/work.d[747];
work.L[920] = (work.KKT[1543])*work.d_inv[747];
work.L[953] = (work.KKT[1544])*work.d_inv[747];
work.v[748] = work.KKT[1545];
work.d[748] = work.v[748];
if (work.d[748] < 0)
work.d[748] = settings.kkt_reg;
else
work.d[748] += settings.kkt_reg;
work.d_inv[748] = 1/work.d[748];
work.L[954] = (work.KKT[1546])*work.d_inv[748];
work.L[987] = (work.KKT[1547])*work.d_inv[748];
work.v[749] = work.KKT[1548];
work.d[749] = work.v[749];
if (work.d[749] < 0)
work.d[749] = settings.kkt_reg;
else
work.d[749] += settings.kkt_reg;
work.d_inv[749] = 1/work.d[749];
work.L[988] = (work.KKT[1549])*work.d_inv[749];
work.L[1021] = (work.KKT[1550])*work.d_inv[749];
work.v[750] = work.KKT[1551];
work.d[750] = work.v[750];
if (work.d[750] < 0)
work.d[750] = settings.kkt_reg;
else
work.d[750] += settings.kkt_reg;
work.d_inv[750] = 1/work.d[750];
work.L[1022] = (work.KKT[1552])*work.d_inv[750];
work.L[1055] = (work.KKT[1553])*work.d_inv[750];
work.v[751] = work.KKT[1554];
work.d[751] = work.v[751];
if (work.d[751] < 0)
work.d[751] = settings.kkt_reg;
else
work.d[751] += settings.kkt_reg;
work.d_inv[751] = 1/work.d[751];
work.L[1056] = (work.KKT[1555])*work.d_inv[751];
work.L[1089] = (work.KKT[1556])*work.d_inv[751];
work.v[752] = work.KKT[1557];
work.d[752] = work.v[752];
if (work.d[752] < 0)
work.d[752] = settings.kkt_reg;
else
work.d[752] += settings.kkt_reg;
work.d_inv[752] = 1/work.d[752];
work.L[1090] = (work.KKT[1558])*work.d_inv[752];
work.L[1123] = (work.KKT[1559])*work.d_inv[752];
work.v[753] = work.KKT[1560];
work.d[753] = work.v[753];
if (work.d[753] < 0)
work.d[753] = settings.kkt_reg;
else
work.d[753] += settings.kkt_reg;
work.d_inv[753] = 1/work.d[753];
work.L[1124] = (work.KKT[1561])*work.d_inv[753];
work.L[1157] = (work.KKT[1562])*work.d_inv[753];
work.v[754] = work.KKT[1563];
work.d[754] = work.v[754];
if (work.d[754] < 0)
work.d[754] = settings.kkt_reg;
else
work.d[754] += settings.kkt_reg;
work.d_inv[754] = 1/work.d[754];
work.L[1158] = (work.KKT[1564])*work.d_inv[754];
work.L[1191] = (work.KKT[1565])*work.d_inv[754];
work.v[755] = work.KKT[1566];
work.d[755] = work.v[755];
if (work.d[755] < 0)
work.d[755] = settings.kkt_reg;
else
work.d[755] += settings.kkt_reg;
work.d_inv[755] = 1/work.d[755];
work.L[1192] = (work.KKT[1567])*work.d_inv[755];
work.L[1225] = (work.KKT[1568])*work.d_inv[755];
work.v[756] = work.KKT[1569];
work.d[756] = work.v[756];
if (work.d[756] < 0)
work.d[756] = settings.kkt_reg;
else
work.d[756] += settings.kkt_reg;
work.d_inv[756] = 1/work.d[756];
work.L[1226] = (work.KKT[1570])*work.d_inv[756];
work.L[1259] = (work.KKT[1571])*work.d_inv[756];
work.v[757] = work.KKT[1572];
work.d[757] = work.v[757];
if (work.d[757] < 0)
work.d[757] = settings.kkt_reg;
else
work.d[757] += settings.kkt_reg;
work.d_inv[757] = 1/work.d[757];
work.L[1260] = (work.KKT[1573])*work.d_inv[757];
work.L[1293] = (work.KKT[1574])*work.d_inv[757];
work.v[758] = work.KKT[1575];
work.d[758] = work.v[758];
if (work.d[758] < 0)
work.d[758] = settings.kkt_reg;
else
work.d[758] += settings.kkt_reg;
work.d_inv[758] = 1/work.d[758];
work.L[1294] = (work.KKT[1576])*work.d_inv[758];
work.L[1327] = (work.KKT[1577])*work.d_inv[758];
work.v[759] = work.KKT[1578];
work.d[759] = work.v[759];
if (work.d[759] < 0)
work.d[759] = settings.kkt_reg;
else
work.d[759] += settings.kkt_reg;
work.d_inv[759] = 1/work.d[759];
work.L[1328] = (work.KKT[1579])*work.d_inv[759];
work.L[1361] = (work.KKT[1580])*work.d_inv[759];
work.v[760] = work.KKT[1581];
work.d[760] = work.v[760];
if (work.d[760] < 0)
work.d[760] = settings.kkt_reg;
else
work.d[760] += settings.kkt_reg;
work.d_inv[760] = 1/work.d[760];
work.L[1362] = (work.KKT[1582])*work.d_inv[760];
work.L[1395] = (work.KKT[1583])*work.d_inv[760];
work.v[761] = work.KKT[1584];
work.d[761] = work.v[761];
if (work.d[761] < 0)
work.d[761] = settings.kkt_reg;
else
work.d[761] += settings.kkt_reg;
work.d_inv[761] = 1/work.d[761];
work.L[1396] = (work.KKT[1585])*work.d_inv[761];
work.L[1429] = (work.KKT[1586])*work.d_inv[761];
work.v[762] = work.KKT[1587];
work.d[762] = work.v[762];
if (work.d[762] < 0)
work.d[762] = settings.kkt_reg;
else
work.d[762] += settings.kkt_reg;
work.d_inv[762] = 1/work.d[762];
work.L[1430] = (work.KKT[1588])*work.d_inv[762];
work.L[1463] = (work.KKT[1589])*work.d_inv[762];
work.v[763] = work.KKT[1590];
work.d[763] = work.v[763];
if (work.d[763] < 0)
work.d[763] = settings.kkt_reg;
else
work.d[763] += settings.kkt_reg;
work.d_inv[763] = 1/work.d[763];
work.L[1464] = (work.KKT[1591])*work.d_inv[763];
work.L[1526] = (work.KKT[1592])*work.d_inv[763];
work.v[764] = work.KKT[1593];
work.d[764] = work.v[764];
if (work.d[764] < 0)
work.d[764] = settings.kkt_reg;
else
work.d[764] += settings.kkt_reg;
work.d_inv[764] = 1/work.d[764];
work.L[784] = (work.KKT[1594])*work.d_inv[764];
work.L[1527] = (work.KKT[1595])*work.d_inv[764];
work.v[738] = work.L[755]*work.d[738];
work.v[765] = work.KKT[1596]-work.L[755]*work.v[738];
work.d[765] = work.v[765];
if (work.d[765] < 0)
work.d[765] = settings.kkt_reg;
else
work.d[765] += settings.kkt_reg;
work.d_inv[765] = 1/work.d[765];
work.L[785] = (work.KKT[1597])*work.d_inv[765];
work.L[1502] = (-work.L[1500]*work.v[738])*work.d_inv[765];
work.v[741] = work.L[756]*work.d[741];
work.v[742] = work.L[757]*work.d[742];
work.v[766] = 0-work.L[756]*work.v[741]-work.L[757]*work.v[742];
work.d[766] = work.v[766];
if (work.d[766] > 0)
work.d[766] = -settings.kkt_reg;
else
work.d[766] -= settings.kkt_reg;
work.d_inv[766] = 1/work.d[766];
work.L[768] = (-work.L[766]*work.v[742])*work.d_inv[766];
work.L[788] = (work.KKT[1598])*work.d_inv[766];
work.L[794] = (work.KKT[1599])*work.d_inv[766];
work.v[767] = 0;
work.d[767] = work.v[767];
if (work.d[767] > 0)
work.d[767] = -settings.kkt_reg;
else
work.d[767] -= settings.kkt_reg;
work.d_inv[767] = 1/work.d[767];
work.L[765] = (work.KKT[1600])*work.d_inv[767];
work.L[795] = (work.KKT[1601])*work.d_inv[767];
work.L[801] = (work.KKT[1602])*work.d_inv[767];
work.v[322] = work.L[758]*work.d[322];
work.v[323] = work.L[759]*work.d[323];
work.v[426] = work.L[760]*work.d[426];
work.v[427] = work.L[761]*work.d[427];
work.v[430] = work.L[762]*work.d[430];
work.v[431] = work.L[763]*work.d[431];
work.v[736] = work.L[764]*work.d[736];
work.v[767] = work.L[765]*work.d[767];
work.v[768] = 0-work.L[758]*work.v[322]-work.L[759]*work.v[323]-work.L[760]*work.v[426]-work.L[761]*work.v[427]-work.L[762]*work.v[430]-work.L[763]*work.v[431]-work.L[764]*work.v[736]-work.L[765]*work.v[767];
work.d[768] = work.v[768];
if (work.d[768] < 0)
work.d[768] = settings.kkt_reg;
else
work.d[768] += settings.kkt_reg;
work.d_inv[768] = 1/work.d[768];
work.L[796] = (-work.L[793]*work.v[736]-work.L[795]*work.v[767])*work.d_inv[768];
work.L[802] = (-work.L[801]*work.v[767])*work.d_inv[768];
work.L[826] = (-work.L[822]*work.v[430]-work.L[823]*work.v[431])*work.d_inv[768];
work.v[742] = work.L[766]*work.d[742];
work.v[743] = work.L[767]*work.d[743];
work.v[766] = work.L[768]*work.d[766];
work.v[769] = 0-work.L[766]*work.v[742]-work.L[767]*work.v[743]-work.L[768]*work.v[766];
work.d[769] = work.v[769];
if (work.d[769] > 0)
work.d[769] = -settings.kkt_reg;
else
work.d[769] -= settings.kkt_reg;
work.d_inv[769] = 1/work.d[769];
work.L[789] = (work.KKT[1603]-work.L[788]*work.v[766])*work.d_inv[769];
work.L[797] = (-work.L[794]*work.v[766])*work.d_inv[769];
work.L[814] = (-work.L[812]*work.v[743])*work.d_inv[769];
work.v[770] = 0;
work.d[770] = work.v[770];
if (work.d[770] > 0)
work.d[770] = -settings.kkt_reg;
else
work.d[770] -= settings.kkt_reg;
work.d_inv[770] = 1/work.d[770];
work.L[803] = (work.KKT[1604])*work.d_inv[770];
work.L[827] = (work.KKT[1605])*work.d_inv[770];
work.L[835] = (work.KKT[1606])*work.d_inv[770];
work.v[771] = 0;
work.d[771] = work.v[771];
if (work.d[771] > 0)
work.d[771] = -settings.kkt_reg;
else
work.d[771] -= settings.kkt_reg;
work.d_inv[771] = 1/work.d[771];
work.L[777] = (work.KKT[1607])*work.d_inv[771];
work.L[782] = (work.KKT[1608])*work.d_inv[771];
work.L[1508] = (work.KKT[1609])*work.d_inv[771];
work.v[414] = work.L[769]*work.d[414];
work.v[415] = work.L[770]*work.d[415];
work.v[518] = work.L[771]*work.d[518];
work.v[519] = work.L[772]*work.d[519];
work.v[522] = work.L[773]*work.d[522];
work.v[523] = work.L[774]*work.d[523];
work.v[734] = work.L[775]*work.d[734];
work.v[740] = work.L[776]*work.d[740];
work.v[771] = work.L[777]*work.d[771];
work.v[772] = 0-work.L[769]*work.v[414]-work.L[770]*work.v[415]-work.L[771]*work.v[518]-work.L[772]*work.v[519]-work.L[773]*work.v[522]-work.L[774]*work.v[523]-work.L[775]*work.v[734]-work.L[776]*work.v[740]-work.L[777]*work.v[771];
work.d[772] = work.v[772];
if (work.d[772] < 0)
work.d[772] = settings.kkt_reg;
else
work.d[772] += settings.kkt_reg;
work.d_inv[772] = 1/work.d[772];
work.L[783] = (-work.L[781]*work.v[740]-work.L[782]*work.v[771])*work.d_inv[772];
work.L[1509] = (-work.L[1508]*work.v[771])*work.d_inv[772];
work.L[1520] = (-work.L[1518]*work.v[518]-work.L[1519]*work.v[519])*work.d_inv[772];
work.v[727] = work.L[778]*work.d[727];
work.v[728] = work.L[779]*work.d[728];
work.v[739] = work.L[780]*work.d[739];
work.v[740] = work.L[781]*work.d[740];
work.v[771] = work.L[782]*work.d[771];
work.v[772] = work.L[783]*work.d[772];
work.v[773] = work.KKT[1610]-work.L[778]*work.v[727]-work.L[779]*work.v[728]-work.L[780]*work.v[739]-work.L[781]*work.v[740]-work.L[782]*work.v[771]-work.L[783]*work.v[772];
work.d[773] = work.v[773];
if (work.d[773] < 0)
work.d[773] = settings.kkt_reg;
else
work.d[773] += settings.kkt_reg;
work.d_inv[773] = 1/work.d[773];
work.L[1503] = (-work.L[1501]*work.v[739])*work.d_inv[773];
work.L[1510] = (-work.L[1508]*work.v[771]-work.L[1509]*work.v[772])*work.d_inv[773];
work.L[1521] = (-work.L[1520]*work.v[772])*work.d_inv[773];
work.v[774] = 0;
work.d[774] = work.v[774];
if (work.d[774] > 0)
work.d[774] = -settings.kkt_reg;
else
work.d[774] -= settings.kkt_reg;
work.d_inv[774] = 1/work.d[774];
work.L[1511] = (work.KKT[1611])*work.d_inv[774];
work.L[1522] = (work.KKT[1612])*work.d_inv[774];
work.L[1549] = (work.KKT[1613])*work.d_inv[774];
work.v[775] = 0;
work.d[775] = work.v[775];
if (work.d[775] > 0)
work.d[775] = -settings.kkt_reg;
else
work.d[775] -= settings.kkt_reg;
work.d_inv[775] = 1/work.d[775];
work.L[1504] = (work.KKT[1614])*work.d_inv[775];
work.L[1512] = (work.KKT[1615])*work.d_inv[775];
work.L[1560] = (work.KKT[1616])*work.d_inv[775];
work.v[764] = work.L[784]*work.d[764];
work.v[765] = work.L[785]*work.d[765];
work.v[776] = 0-work.L[784]*work.v[764]-work.L[785]*work.v[765];
work.d[776] = work.v[776];
if (work.d[776] > 0)
work.d[776] = -settings.kkt_reg;
else
work.d[776] -= settings.kkt_reg;
work.d_inv[776] = 1/work.d[776];
work.L[1505] = (-work.L[1502]*work.v[765])*work.d_inv[776];
work.L[1528] = (-work.L[1527]*work.v[764])*work.d_inv[776];
work.L[1561] = (work.KKT[1617])*work.d_inv[776];
work.v[530] = work.L[786]*work.d[530];
work.v[531] = work.L[787]*work.d[531];
work.v[766] = work.L[788]*work.d[766];
work.v[769] = work.L[789]*work.d[769];
work.v[777] = work.KKT[1618]-work.L[786]*work.v[530]-work.L[787]*work.v[531]-work.L[788]*work.v[766]-work.L[789]*work.v[769];
work.d[777] = work.v[777];
if (work.d[777] < 0)
work.d[777] = settings.kkt_reg;
else
work.d[777] += settings.kkt_reg;
work.d_inv[777] = 1/work.d[777];
work.L[798] = (-work.L[794]*work.v[766]-work.L[797]*work.v[769])*work.d_inv[777];
work.L[805] = (work.KKT[1619])*work.d_inv[777];
work.L[815] = (-work.L[814]*work.v[769])*work.d_inv[777];
work.v[631] = work.L[790]*work.d[631];
work.v[632] = work.L[791]*work.d[632];
work.v[735] = work.L[792]*work.d[735];
work.v[736] = work.L[793]*work.d[736];
work.v[766] = work.L[794]*work.d[766];
work.v[767] = work.L[795]*work.d[767];
work.v[768] = work.L[796]*work.d[768];
work.v[769] = work.L[797]*work.d[769];
work.v[777] = work.L[798]*work.d[777];
work.v[778] = work.KKT[1620]-work.L[790]*work.v[631]-work.L[791]*work.v[632]-work.L[792]*work.v[735]-work.L[793]*work.v[736]-work.L[794]*work.v[766]-work.L[795]*work.v[767]-work.L[796]*work.v[768]-work.L[797]*work.v[769]-work.L[798]*work.v[777];
work.d[778] = work.v[778];
if (work.d[778] < 0)
work.d[778] = settings.kkt_reg;
else
work.d[778] += settings.kkt_reg;
work.d_inv[778] = 1/work.d[778];
work.L[804] = (-work.L[801]*work.v[767]-work.L[802]*work.v[768])*work.d_inv[778];
work.L[806] = (-work.L[805]*work.v[777])*work.d_inv[778];
work.L[816] = (-work.L[814]*work.v[769]-work.L[815]*work.v[777])*work.d_inv[778];
work.L[828] = (-work.L[826]*work.v[768])*work.d_inv[778];
work.v[635] = work.L[799]*work.d[635];
work.v[636] = work.L[800]*work.d[636];
work.v[767] = work.L[801]*work.d[767];
work.v[768] = work.L[802]*work.d[768];
work.v[770] = work.L[803]*work.d[770];
work.v[778] = work.L[804]*work.d[778];
work.v[779] = work.KKT[1621]-work.L[799]*work.v[635]-work.L[800]*work.v[636]-work.L[801]*work.v[767]-work.L[802]*work.v[768]-work.L[803]*work.v[770]-work.L[804]*work.v[778];
work.d[779] = work.v[779];
if (work.d[779] < 0)
work.d[779] = settings.kkt_reg;
else
work.d[779] += settings.kkt_reg;
work.d_inv[779] = 1/work.d[779];
work.L[807] = (work.KKT[1622]-work.L[806]*work.v[778])*work.d_inv[779];
work.L[817] = (-work.L[816]*work.v[778])*work.d_inv[779];
work.L[829] = (-work.L[826]*work.v[768]-work.L[827]*work.v[770]-work.L[828]*work.v[778])*work.d_inv[779];
work.L[836] = (-work.L[835]*work.v[770])*work.d_inv[779];
work.v[777] = work.L[805]*work.d[777];
work.v[778] = work.L[806]*work.d[778];
work.v[779] = work.L[807]*work.d[779];
work.v[780] = 0-work.L[805]*work.v[777]-work.L[806]*work.v[778]-work.L[807]*work.v[779];
work.d[780] = work.v[780];
if (work.d[780] > 0)
work.d[780] = -settings.kkt_reg;
else
work.d[780] -= settings.kkt_reg;
work.d_inv[780] = 1/work.d[780];
work.L[810] = (work.KKT[1623])*work.d_inv[780];
work.L[818] = (-work.L[815]*work.v[777]-work.L[816]*work.v[778]-work.L[817]*work.v[779])*work.d_inv[780];
work.L[830] = (-work.L[828]*work.v[778]-work.L[829]*work.v[779])*work.d_inv[780];
work.L[837] = (-work.L[836]*work.v[779])*work.d_inv[780];
work.v[781] = 0;
work.d[781] = work.v[781];
if (work.d[781] > 0)
work.d[781] = -settings.kkt_reg;
else
work.d[781] -= settings.kkt_reg;
work.d_inv[781] = 1/work.d[781];
work.L[811] = (work.KKT[1624])*work.d_inv[781];
work.L[838] = (work.KKT[1625])*work.d_inv[781];
work.L[845] = (work.KKT[1626])*work.d_inv[781];
work.v[534] = work.L[808]*work.d[534];
work.v[535] = work.L[809]*work.d[535];
work.v[780] = work.L[810]*work.d[780];
work.v[781] = work.L[811]*work.d[781];
work.v[782] = work.KKT[1627]-work.L[808]*work.v[534]-work.L[809]*work.v[535]-work.L[810]*work.v[780]-work.L[811]*work.v[781];
work.d[782] = work.v[782];
if (work.d[782] < 0)
work.d[782] = settings.kkt_reg;
else
work.d[782] += settings.kkt_reg;
work.d_inv[782] = 1/work.d[782];
work.L[819] = (work.KKT[1628]-work.L[818]*work.v[780])*work.d_inv[782];
work.L[831] = (-work.L[830]*work.v[780])*work.d_inv[782];
work.L[839] = (-work.L[837]*work.v[780]-work.L[838]*work.v[781])*work.d_inv[782];
work.L[846] = (-work.L[845]*work.v[781])*work.d_inv[782];
work.v[743] = work.L[812]*work.d[743];
work.v[744] = work.L[813]*work.d[744];
work.v[769] = work.L[814]*work.d[769];
work.v[777] = work.L[815]*work.d[777];
work.v[778] = work.L[816]*work.d[778];
work.v[779] = work.L[817]*work.d[779];
work.v[780] = work.L[818]*work.d[780];
work.v[782] = work.L[819]*work.d[782];
work.v[783] = 0-work.L[812]*work.v[743]-work.L[813]*work.v[744]-work.L[814]*work.v[769]-work.L[815]*work.v[777]-work.L[816]*work.v[778]-work.L[817]*work.v[779]-work.L[818]*work.v[780]-work.L[819]*work.v[782];
work.d[783] = work.v[783];
if (work.d[783] > 0)
work.d[783] = -settings.kkt_reg;
else
work.d[783] -= settings.kkt_reg;
work.d_inv[783] = 1/work.d[783];
work.L[832] = (-work.L[828]*work.v[778]-work.L[829]*work.v[779]-work.L[830]*work.v[780]-work.L[831]*work.v[782])*work.d_inv[783];
work.L[840] = (-work.L[836]*work.v[779]-work.L[837]*work.v[780]-work.L[839]*work.v[782])*work.d_inv[783];
work.L[847] = (-work.L[846]*work.v[782])*work.d_inv[783];
work.L[853] = (-work.L[851]*work.v[744])*work.d_inv[783];
work.v[326] = work.L[820]*work.d[326];
work.v[327] = work.L[821]*work.d[327];
work.v[430] = work.L[822]*work.d[430];
work.v[431] = work.L[823]*work.d[431];
work.v[434] = work.L[824]*work.d[434];
work.v[435] = work.L[825]*work.d[435];
work.v[768] = work.L[826]*work.d[768];
work.v[770] = work.L[827]*work.d[770];
work.v[778] = work.L[828]*work.d[778];
work.v[779] = work.L[829]*work.d[779];
work.v[780] = work.L[830]*work.d[780];
work.v[782] = work.L[831]*work.d[782];
work.v[783] = work.L[832]*work.d[783];
work.v[784] = 0-work.L[820]*work.v[326]-work.L[821]*work.v[327]-work.L[822]*work.v[430]-work.L[823]*work.v[431]-work.L[824]*work.v[434]-work.L[825]*work.v[435]-work.L[826]*work.v[768]-work.L[827]*work.v[770]-work.L[828]*work.v[778]-work.L[829]*work.v[779]-work.L[830]*work.v[780]-work.L[831]*work.v[782]-work.L[832]*work.v[783];
work.d[784] = work.v[784];
if (work.d[784] < 0)
work.d[784] = settings.kkt_reg;
else
work.d[784] += settings.kkt_reg;
work.d_inv[784] = 1/work.d[784];
work.L[841] = (-work.L[835]*work.v[770]-work.L[836]*work.v[779]-work.L[837]*work.v[780]-work.L[839]*work.v[782]-work.L[840]*work.v[783])*work.d_inv[784];
work.L[848] = (-work.L[846]*work.v[782]-work.L[847]*work.v[783])*work.d_inv[784];
work.L[854] = (-work.L[853]*work.v[783])*work.d_inv[784];
work.L[863] = (-work.L[859]*work.v[434]-work.L[860]*work.v[435])*work.d_inv[784];
work.v[785] = 0;
work.d[785] = work.v[785];
if (work.d[785] > 0)
work.d[785] = -settings.kkt_reg;
else
work.d[785] -= settings.kkt_reg;
work.d_inv[785] = 1/work.d[785];
work.L[842] = (work.KKT[1629])*work.d_inv[785];
work.L[864] = (work.KKT[1630])*work.d_inv[785];
work.L[870] = (work.KKT[1631])*work.d_inv[785];
work.v[639] = work.L[833]*work.d[639];
work.v[640] = work.L[834]*work.d[640];
work.v[770] = work.L[835]*work.d[770];
work.v[779] = work.L[836]*work.d[779];
work.v[780] = work.L[837]*work.d[780];
work.v[781] = work.L[838]*work.d[781];
work.v[782] = work.L[839]*work.d[782];
work.v[783] = work.L[840]*work.d[783];
work.v[784] = work.L[841]*work.d[784];
work.v[785] = work.L[842]*work.d[785];
work.v[786] = work.KKT[1632]-work.L[833]*work.v[639]-work.L[834]*work.v[640]-work.L[835]*work.v[770]-work.L[836]*work.v[779]-work.L[837]*work.v[780]-work.L[838]*work.v[781]-work.L[839]*work.v[782]-work.L[840]*work.v[783]-work.L[841]*work.v[784]-work.L[842]*work.v[785];
work.d[786] = work.v[786];
if (work.d[786] < 0)
work.d[786] = settings.kkt_reg;
else
work.d[786] += settings.kkt_reg;
work.d_inv[786] = 1/work.d[786];
work.L[849] = (-work.L[845]*work.v[781]-work.L[846]*work.v[782]-work.L[847]*work.v[783]-work.L[848]*work.v[784])*work.d_inv[786];
work.L[855] = (-work.L[853]*work.v[783]-work.L[854]*work.v[784])*work.d_inv[786];
work.L[865] = (-work.L[863]*work.v[784]-work.L[864]*work.v[785])*work.d_inv[786];
work.L[871] = (-work.L[870]*work.v[785])*work.d_inv[786];
work.v[787] = 0;
work.d[787] = work.v[787];
if (work.d[787] > 0)
work.d[787] = -settings.kkt_reg;
else
work.d[787] -= settings.kkt_reg;
work.d_inv[787] = 1/work.d[787];
work.L[850] = (work.KKT[1633])*work.d_inv[787];
work.L[872] = (work.KKT[1634])*work.d_inv[787];
work.L[879] = (work.KKT[1635])*work.d_inv[787];
work.v[538] = work.L[843]*work.d[538];
work.v[539] = work.L[844]*work.d[539];
work.v[781] = work.L[845]*work.d[781];
work.v[782] = work.L[846]*work.d[782];
work.v[783] = work.L[847]*work.d[783];
work.v[784] = work.L[848]*work.d[784];
work.v[786] = work.L[849]*work.d[786];
work.v[787] = work.L[850]*work.d[787];
work.v[788] = work.KKT[1636]-work.L[843]*work.v[538]-work.L[844]*work.v[539]-work.L[845]*work.v[781]-work.L[846]*work.v[782]-work.L[847]*work.v[783]-work.L[848]*work.v[784]-work.L[849]*work.v[786]-work.L[850]*work.v[787];
work.d[788] = work.v[788];
if (work.d[788] < 0)
work.d[788] = settings.kkt_reg;
else
work.d[788] += settings.kkt_reg;
work.d_inv[788] = 1/work.d[788];
work.L[856] = (work.KKT[1637]-work.L[853]*work.v[783]-work.L[854]*work.v[784]-work.L[855]*work.v[786])*work.d_inv[788];
work.L[866] = (-work.L[863]*work.v[784]-work.L[865]*work.v[786])*work.d_inv[788];
work.L[873] = (-work.L[871]*work.v[786]-work.L[872]*work.v[787])*work.d_inv[788];
work.L[880] = (-work.L[879]*work.v[787])*work.d_inv[788];
work.v[744] = work.L[851]*work.d[744];
work.v[745] = work.L[852]*work.d[745];
work.v[783] = work.L[853]*work.d[783];
work.v[784] = work.L[854]*work.d[784];
work.v[786] = work.L[855]*work.d[786];
work.v[788] = work.L[856]*work.d[788];
work.v[789] = 0-work.L[851]*work.v[744]-work.L[852]*work.v[745]-work.L[853]*work.v[783]-work.L[854]*work.v[784]-work.L[855]*work.v[786]-work.L[856]*work.v[788];
work.d[789] = work.v[789];
if (work.d[789] > 0)
work.d[789] = -settings.kkt_reg;
else
work.d[789] -= settings.kkt_reg;
work.d_inv[789] = 1/work.d[789];
work.L[867] = (-work.L[863]*work.v[784]-work.L[865]*work.v[786]-work.L[866]*work.v[788])*work.d_inv[789];
work.L[874] = (-work.L[871]*work.v[786]-work.L[873]*work.v[788])*work.d_inv[789];
work.L[881] = (-work.L[880]*work.v[788])*work.d_inv[789];
work.L[887] = (-work.L[885]*work.v[745])*work.d_inv[789];
work.v[330] = work.L[857]*work.d[330];
work.v[331] = work.L[858]*work.d[331];
work.v[434] = work.L[859]*work.d[434];
work.v[435] = work.L[860]*work.d[435];
work.v[438] = work.L[861]*work.d[438];
work.v[439] = work.L[862]*work.d[439];
work.v[784] = work.L[863]*work.d[784];
work.v[785] = work.L[864]*work.d[785];
work.v[786] = work.L[865]*work.d[786];
work.v[788] = work.L[866]*work.d[788];
work.v[789] = work.L[867]*work.d[789];
work.v[790] = 0-work.L[857]*work.v[330]-work.L[858]*work.v[331]-work.L[859]*work.v[434]-work.L[860]*work.v[435]-work.L[861]*work.v[438]-work.L[862]*work.v[439]-work.L[863]*work.v[784]-work.L[864]*work.v[785]-work.L[865]*work.v[786]-work.L[866]*work.v[788]-work.L[867]*work.v[789];
work.d[790] = work.v[790];
if (work.d[790] < 0)
work.d[790] = settings.kkt_reg;
else
work.d[790] += settings.kkt_reg;
work.d_inv[790] = 1/work.d[790];
work.L[875] = (-work.L[870]*work.v[785]-work.L[871]*work.v[786]-work.L[873]*work.v[788]-work.L[874]*work.v[789])*work.d_inv[790];
work.L[882] = (-work.L[880]*work.v[788]-work.L[881]*work.v[789])*work.d_inv[790];
work.L[888] = (-work.L[887]*work.v[789])*work.d_inv[790];
work.L[897] = (-work.L[893]*work.v[438]-work.L[894]*work.v[439])*work.d_inv[790];
work.v[791] = 0;
work.d[791] = work.v[791];
if (work.d[791] > 0)
work.d[791] = -settings.kkt_reg;
else
work.d[791] -= settings.kkt_reg;
work.d_inv[791] = 1/work.d[791];
work.L[876] = (work.KKT[1638])*work.d_inv[791];
work.L[898] = (work.KKT[1639])*work.d_inv[791];
work.L[904] = (work.KKT[1640])*work.d_inv[791];
work.v[643] = work.L[868]*work.d[643];
work.v[644] = work.L[869]*work.d[644];
work.v[785] = work.L[870]*work.d[785];
work.v[786] = work.L[871]*work.d[786];
work.v[787] = work.L[872]*work.d[787];
work.v[788] = work.L[873]*work.d[788];
work.v[789] = work.L[874]*work.d[789];
work.v[790] = work.L[875]*work.d[790];
work.v[791] = work.L[876]*work.d[791];
work.v[792] = work.KKT[1641]-work.L[868]*work.v[643]-work.L[869]*work.v[644]-work.L[870]*work.v[785]-work.L[871]*work.v[786]-work.L[872]*work.v[787]-work.L[873]*work.v[788]-work.L[874]*work.v[789]-work.L[875]*work.v[790]-work.L[876]*work.v[791];
work.d[792] = work.v[792];
if (work.d[792] < 0)
work.d[792] = settings.kkt_reg;
else
work.d[792] += settings.kkt_reg;
work.d_inv[792] = 1/work.d[792];
work.L[883] = (-work.L[879]*work.v[787]-work.L[880]*work.v[788]-work.L[881]*work.v[789]-work.L[882]*work.v[790])*work.d_inv[792];
work.L[889] = (-work.L[887]*work.v[789]-work.L[888]*work.v[790])*work.d_inv[792];
work.L[899] = (-work.L[897]*work.v[790]-work.L[898]*work.v[791])*work.d_inv[792];
work.L[905] = (-work.L[904]*work.v[791])*work.d_inv[792];
work.v[793] = 0;
work.d[793] = work.v[793];
if (work.d[793] > 0)
work.d[793] = -settings.kkt_reg;
else
work.d[793] -= settings.kkt_reg;
work.d_inv[793] = 1/work.d[793];
work.L[884] = (work.KKT[1642])*work.d_inv[793];
work.L[906] = (work.KKT[1643])*work.d_inv[793];
work.L[913] = (work.KKT[1644])*work.d_inv[793];
work.v[542] = work.L[877]*work.d[542];
work.v[543] = work.L[878]*work.d[543];
work.v[787] = work.L[879]*work.d[787];
work.v[788] = work.L[880]*work.d[788];
work.v[789] = work.L[881]*work.d[789];
work.v[790] = work.L[882]*work.d[790];
work.v[792] = work.L[883]*work.d[792];
work.v[793] = work.L[884]*work.d[793];
work.v[794] = work.KKT[1645]-work.L[877]*work.v[542]-work.L[878]*work.v[543]-work.L[879]*work.v[787]-work.L[880]*work.v[788]-work.L[881]*work.v[789]-work.L[882]*work.v[790]-work.L[883]*work.v[792]-work.L[884]*work.v[793];
work.d[794] = work.v[794];
if (work.d[794] < 0)
work.d[794] = settings.kkt_reg;
else
work.d[794] += settings.kkt_reg;
work.d_inv[794] = 1/work.d[794];
work.L[890] = (work.KKT[1646]-work.L[887]*work.v[789]-work.L[888]*work.v[790]-work.L[889]*work.v[792])*work.d_inv[794];
work.L[900] = (-work.L[897]*work.v[790]-work.L[899]*work.v[792])*work.d_inv[794];
work.L[907] = (-work.L[905]*work.v[792]-work.L[906]*work.v[793])*work.d_inv[794];
work.L[914] = (-work.L[913]*work.v[793])*work.d_inv[794];
work.v[745] = work.L[885]*work.d[745];
work.v[746] = work.L[886]*work.d[746];
work.v[789] = work.L[887]*work.d[789];
work.v[790] = work.L[888]*work.d[790];
work.v[792] = work.L[889]*work.d[792];
work.v[794] = work.L[890]*work.d[794];
work.v[795] = 0-work.L[885]*work.v[745]-work.L[886]*work.v[746]-work.L[887]*work.v[789]-work.L[888]*work.v[790]-work.L[889]*work.v[792]-work.L[890]*work.v[794];
work.d[795] = work.v[795];
if (work.d[795] > 0)
work.d[795] = -settings.kkt_reg;
else
work.d[795] -= settings.kkt_reg;
work.d_inv[795] = 1/work.d[795];
work.L[901] = (-work.L[897]*work.v[790]-work.L[899]*work.v[792]-work.L[900]*work.v[794])*work.d_inv[795];
work.L[908] = (-work.L[905]*work.v[792]-work.L[907]*work.v[794])*work.d_inv[795];
work.L[915] = (-work.L[914]*work.v[794])*work.d_inv[795];
work.L[921] = (-work.L[919]*work.v[746])*work.d_inv[795];
work.v[334] = work.L[891]*work.d[334];
work.v[335] = work.L[892]*work.d[335];
work.v[438] = work.L[893]*work.d[438];
work.v[439] = work.L[894]*work.d[439];
work.v[442] = work.L[895]*work.d[442];
work.v[443] = work.L[896]*work.d[443];
work.v[790] = work.L[897]*work.d[790];
work.v[791] = work.L[898]*work.d[791];
work.v[792] = work.L[899]*work.d[792];
work.v[794] = work.L[900]*work.d[794];
work.v[795] = work.L[901]*work.d[795];
work.v[796] = 0-work.L[891]*work.v[334]-work.L[892]*work.v[335]-work.L[893]*work.v[438]-work.L[894]*work.v[439]-work.L[895]*work.v[442]-work.L[896]*work.v[443]-work.L[897]*work.v[790]-work.L[898]*work.v[791]-work.L[899]*work.v[792]-work.L[900]*work.v[794]-work.L[901]*work.v[795];
work.d[796] = work.v[796];
if (work.d[796] < 0)
work.d[796] = settings.kkt_reg;
else
work.d[796] += settings.kkt_reg;
work.d_inv[796] = 1/work.d[796];
work.L[909] = (-work.L[904]*work.v[791]-work.L[905]*work.v[792]-work.L[907]*work.v[794]-work.L[908]*work.v[795])*work.d_inv[796];
work.L[916] = (-work.L[914]*work.v[794]-work.L[915]*work.v[795])*work.d_inv[796];
work.L[922] = (-work.L[921]*work.v[795])*work.d_inv[796];
work.L[931] = (-work.L[927]*work.v[442]-work.L[928]*work.v[443])*work.d_inv[796];
work.v[797] = 0;
work.d[797] = work.v[797];
if (work.d[797] > 0)
work.d[797] = -settings.kkt_reg;
else
work.d[797] -= settings.kkt_reg;
work.d_inv[797] = 1/work.d[797];
work.L[910] = (work.KKT[1647])*work.d_inv[797];
work.L[932] = (work.KKT[1648])*work.d_inv[797];
work.L[938] = (work.KKT[1649])*work.d_inv[797];
work.v[647] = work.L[902]*work.d[647];
work.v[648] = work.L[903]*work.d[648];
work.v[791] = work.L[904]*work.d[791];
work.v[792] = work.L[905]*work.d[792];
work.v[793] = work.L[906]*work.d[793];
work.v[794] = work.L[907]*work.d[794];
work.v[795] = work.L[908]*work.d[795];
work.v[796] = work.L[909]*work.d[796];
work.v[797] = work.L[910]*work.d[797];
work.v[798] = work.KKT[1650]-work.L[902]*work.v[647]-work.L[903]*work.v[648]-work.L[904]*work.v[791]-work.L[905]*work.v[792]-work.L[906]*work.v[793]-work.L[907]*work.v[794]-work.L[908]*work.v[795]-work.L[909]*work.v[796]-work.L[910]*work.v[797];
work.d[798] = work.v[798];
if (work.d[798] < 0)
work.d[798] = settings.kkt_reg;
else
work.d[798] += settings.kkt_reg;
work.d_inv[798] = 1/work.d[798];
work.L[917] = (-work.L[913]*work.v[793]-work.L[914]*work.v[794]-work.L[915]*work.v[795]-work.L[916]*work.v[796])*work.d_inv[798];
work.L[923] = (-work.L[921]*work.v[795]-work.L[922]*work.v[796])*work.d_inv[798];
work.L[933] = (-work.L[931]*work.v[796]-work.L[932]*work.v[797])*work.d_inv[798];
work.L[939] = (-work.L[938]*work.v[797])*work.d_inv[798];
work.v[799] = 0;
work.d[799] = work.v[799];
if (work.d[799] > 0)
work.d[799] = -settings.kkt_reg;
else
work.d[799] -= settings.kkt_reg;
work.d_inv[799] = 1/work.d[799];
work.L[918] = (work.KKT[1651])*work.d_inv[799];
work.L[940] = (work.KKT[1652])*work.d_inv[799];
work.L[947] = (work.KKT[1653])*work.d_inv[799];
work.v[546] = work.L[911]*work.d[546];
work.v[547] = work.L[912]*work.d[547];
work.v[793] = work.L[913]*work.d[793];
work.v[794] = work.L[914]*work.d[794];
work.v[795] = work.L[915]*work.d[795];
work.v[796] = work.L[916]*work.d[796];
work.v[798] = work.L[917]*work.d[798];
work.v[799] = work.L[918]*work.d[799];
work.v[800] = work.KKT[1654]-work.L[911]*work.v[546]-work.L[912]*work.v[547]-work.L[913]*work.v[793]-work.L[914]*work.v[794]-work.L[915]*work.v[795]-work.L[916]*work.v[796]-work.L[917]*work.v[798]-work.L[918]*work.v[799];
work.d[800] = work.v[800];
if (work.d[800] < 0)
work.d[800] = settings.kkt_reg;
else
work.d[800] += settings.kkt_reg;
work.d_inv[800] = 1/work.d[800];
work.L[924] = (work.KKT[1655]-work.L[921]*work.v[795]-work.L[922]*work.v[796]-work.L[923]*work.v[798])*work.d_inv[800];
work.L[934] = (-work.L[931]*work.v[796]-work.L[933]*work.v[798])*work.d_inv[800];
work.L[941] = (-work.L[939]*work.v[798]-work.L[940]*work.v[799])*work.d_inv[800];
work.L[948] = (-work.L[947]*work.v[799])*work.d_inv[800];
work.v[746] = work.L[919]*work.d[746];
work.v[747] = work.L[920]*work.d[747];
work.v[795] = work.L[921]*work.d[795];
work.v[796] = work.L[922]*work.d[796];
work.v[798] = work.L[923]*work.d[798];
work.v[800] = work.L[924]*work.d[800];
work.v[801] = 0-work.L[919]*work.v[746]-work.L[920]*work.v[747]-work.L[921]*work.v[795]-work.L[922]*work.v[796]-work.L[923]*work.v[798]-work.L[924]*work.v[800];
work.d[801] = work.v[801];
if (work.d[801] > 0)
work.d[801] = -settings.kkt_reg;
else
work.d[801] -= settings.kkt_reg;
work.d_inv[801] = 1/work.d[801];
work.L[935] = (-work.L[931]*work.v[796]-work.L[933]*work.v[798]-work.L[934]*work.v[800])*work.d_inv[801];
work.L[942] = (-work.L[939]*work.v[798]-work.L[941]*work.v[800])*work.d_inv[801];
work.L[949] = (-work.L[948]*work.v[800])*work.d_inv[801];
work.L[955] = (-work.L[953]*work.v[747])*work.d_inv[801];
work.v[338] = work.L[925]*work.d[338];
work.v[339] = work.L[926]*work.d[339];
work.v[442] = work.L[927]*work.d[442];
work.v[443] = work.L[928]*work.d[443];
work.v[446] = work.L[929]*work.d[446];
work.v[447] = work.L[930]*work.d[447];
work.v[796] = work.L[931]*work.d[796];
work.v[797] = work.L[932]*work.d[797];
work.v[798] = work.L[933]*work.d[798];
work.v[800] = work.L[934]*work.d[800];
work.v[801] = work.L[935]*work.d[801];
work.v[802] = 0-work.L[925]*work.v[338]-work.L[926]*work.v[339]-work.L[927]*work.v[442]-work.L[928]*work.v[443]-work.L[929]*work.v[446]-work.L[930]*work.v[447]-work.L[931]*work.v[796]-work.L[932]*work.v[797]-work.L[933]*work.v[798]-work.L[934]*work.v[800]-work.L[935]*work.v[801];
work.d[802] = work.v[802];
if (work.d[802] < 0)
work.d[802] = settings.kkt_reg;
else
work.d[802] += settings.kkt_reg;
work.d_inv[802] = 1/work.d[802];
work.L[943] = (-work.L[938]*work.v[797]-work.L[939]*work.v[798]-work.L[941]*work.v[800]-work.L[942]*work.v[801])*work.d_inv[802];
work.L[950] = (-work.L[948]*work.v[800]-work.L[949]*work.v[801])*work.d_inv[802];
work.L[956] = (-work.L[955]*work.v[801])*work.d_inv[802];
work.L[965] = (-work.L[961]*work.v[446]-work.L[962]*work.v[447])*work.d_inv[802];
work.v[803] = 0;
work.d[803] = work.v[803];
if (work.d[803] > 0)
work.d[803] = -settings.kkt_reg;
else
work.d[803] -= settings.kkt_reg;
work.d_inv[803] = 1/work.d[803];
work.L[944] = (work.KKT[1656])*work.d_inv[803];
work.L[966] = (work.KKT[1657])*work.d_inv[803];
work.L[972] = (work.KKT[1658])*work.d_inv[803];
work.v[651] = work.L[936]*work.d[651];
work.v[652] = work.L[937]*work.d[652];
work.v[797] = work.L[938]*work.d[797];
work.v[798] = work.L[939]*work.d[798];
work.v[799] = work.L[940]*work.d[799];
work.v[800] = work.L[941]*work.d[800];
work.v[801] = work.L[942]*work.d[801];
work.v[802] = work.L[943]*work.d[802];
work.v[803] = work.L[944]*work.d[803];
work.v[804] = work.KKT[1659]-work.L[936]*work.v[651]-work.L[937]*work.v[652]-work.L[938]*work.v[797]-work.L[939]*work.v[798]-work.L[940]*work.v[799]-work.L[941]*work.v[800]-work.L[942]*work.v[801]-work.L[943]*work.v[802]-work.L[944]*work.v[803];
work.d[804] = work.v[804];
if (work.d[804] < 0)
work.d[804] = settings.kkt_reg;
else
work.d[804] += settings.kkt_reg;
work.d_inv[804] = 1/work.d[804];
work.L[951] = (-work.L[947]*work.v[799]-work.L[948]*work.v[800]-work.L[949]*work.v[801]-work.L[950]*work.v[802])*work.d_inv[804];
work.L[957] = (-work.L[955]*work.v[801]-work.L[956]*work.v[802])*work.d_inv[804];
work.L[967] = (-work.L[965]*work.v[802]-work.L[966]*work.v[803])*work.d_inv[804];
work.L[973] = (-work.L[972]*work.v[803])*work.d_inv[804];
work.v[805] = 0;
work.d[805] = work.v[805];
if (work.d[805] > 0)
work.d[805] = -settings.kkt_reg;
else
work.d[805] -= settings.kkt_reg;
work.d_inv[805] = 1/work.d[805];
work.L[952] = (work.KKT[1660])*work.d_inv[805];
work.L[974] = (work.KKT[1661])*work.d_inv[805];
work.L[981] = (work.KKT[1662])*work.d_inv[805];
work.v[550] = work.L[945]*work.d[550];
work.v[551] = work.L[946]*work.d[551];
work.v[799] = work.L[947]*work.d[799];
work.v[800] = work.L[948]*work.d[800];
work.v[801] = work.L[949]*work.d[801];
work.v[802] = work.L[950]*work.d[802];
work.v[804] = work.L[951]*work.d[804];
work.v[805] = work.L[952]*work.d[805];
work.v[806] = work.KKT[1663]-work.L[945]*work.v[550]-work.L[946]*work.v[551]-work.L[947]*work.v[799]-work.L[948]*work.v[800]-work.L[949]*work.v[801]-work.L[950]*work.v[802]-work.L[951]*work.v[804]-work.L[952]*work.v[805];
work.d[806] = work.v[806];
if (work.d[806] < 0)
work.d[806] = settings.kkt_reg;
else
work.d[806] += settings.kkt_reg;
work.d_inv[806] = 1/work.d[806];
work.L[958] = (work.KKT[1664]-work.L[955]*work.v[801]-work.L[956]*work.v[802]-work.L[957]*work.v[804])*work.d_inv[806];
work.L[968] = (-work.L[965]*work.v[802]-work.L[967]*work.v[804])*work.d_inv[806];
work.L[975] = (-work.L[973]*work.v[804]-work.L[974]*work.v[805])*work.d_inv[806];
work.L[982] = (-work.L[981]*work.v[805])*work.d_inv[806];
work.v[747] = work.L[953]*work.d[747];
work.v[748] = work.L[954]*work.d[748];
work.v[801] = work.L[955]*work.d[801];
work.v[802] = work.L[956]*work.d[802];
work.v[804] = work.L[957]*work.d[804];
work.v[806] = work.L[958]*work.d[806];
work.v[807] = 0-work.L[953]*work.v[747]-work.L[954]*work.v[748]-work.L[955]*work.v[801]-work.L[956]*work.v[802]-work.L[957]*work.v[804]-work.L[958]*work.v[806];
work.d[807] = work.v[807];
if (work.d[807] > 0)
work.d[807] = -settings.kkt_reg;
else
work.d[807] -= settings.kkt_reg;
work.d_inv[807] = 1/work.d[807];
work.L[969] = (-work.L[965]*work.v[802]-work.L[967]*work.v[804]-work.L[968]*work.v[806])*work.d_inv[807];
work.L[976] = (-work.L[973]*work.v[804]-work.L[975]*work.v[806])*work.d_inv[807];
work.L[983] = (-work.L[982]*work.v[806])*work.d_inv[807];
work.L[989] = (-work.L[987]*work.v[748])*work.d_inv[807];
work.v[342] = work.L[959]*work.d[342];
work.v[343] = work.L[960]*work.d[343];
work.v[446] = work.L[961]*work.d[446];
work.v[447] = work.L[962]*work.d[447];
work.v[450] = work.L[963]*work.d[450];
work.v[451] = work.L[964]*work.d[451];
work.v[802] = work.L[965]*work.d[802];
work.v[803] = work.L[966]*work.d[803];
work.v[804] = work.L[967]*work.d[804];
work.v[806] = work.L[968]*work.d[806];
work.v[807] = work.L[969]*work.d[807];
work.v[808] = 0-work.L[959]*work.v[342]-work.L[960]*work.v[343]-work.L[961]*work.v[446]-work.L[962]*work.v[447]-work.L[963]*work.v[450]-work.L[964]*work.v[451]-work.L[965]*work.v[802]-work.L[966]*work.v[803]-work.L[967]*work.v[804]-work.L[968]*work.v[806]-work.L[969]*work.v[807];
work.d[808] = work.v[808];
if (work.d[808] < 0)
work.d[808] = settings.kkt_reg;
else
work.d[808] += settings.kkt_reg;
work.d_inv[808] = 1/work.d[808];
work.L[977] = (-work.L[972]*work.v[803]-work.L[973]*work.v[804]-work.L[975]*work.v[806]-work.L[976]*work.v[807])*work.d_inv[808];
work.L[984] = (-work.L[982]*work.v[806]-work.L[983]*work.v[807])*work.d_inv[808];
work.L[990] = (-work.L[989]*work.v[807])*work.d_inv[808];
work.L[999] = (-work.L[995]*work.v[450]-work.L[996]*work.v[451])*work.d_inv[808];
work.v[809] = 0;
work.d[809] = work.v[809];
if (work.d[809] > 0)
work.d[809] = -settings.kkt_reg;
else
work.d[809] -= settings.kkt_reg;
work.d_inv[809] = 1/work.d[809];
work.L[978] = (work.KKT[1665])*work.d_inv[809];
work.L[1000] = (work.KKT[1666])*work.d_inv[809];
work.L[1006] = (work.KKT[1667])*work.d_inv[809];
work.v[655] = work.L[970]*work.d[655];
work.v[656] = work.L[971]*work.d[656];
work.v[803] = work.L[972]*work.d[803];
work.v[804] = work.L[973]*work.d[804];
work.v[805] = work.L[974]*work.d[805];
work.v[806] = work.L[975]*work.d[806];
work.v[807] = work.L[976]*work.d[807];
work.v[808] = work.L[977]*work.d[808];
work.v[809] = work.L[978]*work.d[809];
work.v[810] = work.KKT[1668]-work.L[970]*work.v[655]-work.L[971]*work.v[656]-work.L[972]*work.v[803]-work.L[973]*work.v[804]-work.L[974]*work.v[805]-work.L[975]*work.v[806]-work.L[976]*work.v[807]-work.L[977]*work.v[808]-work.L[978]*work.v[809];
work.d[810] = work.v[810];
if (work.d[810] < 0)
work.d[810] = settings.kkt_reg;
else
work.d[810] += settings.kkt_reg;
work.d_inv[810] = 1/work.d[810];
work.L[985] = (-work.L[981]*work.v[805]-work.L[982]*work.v[806]-work.L[983]*work.v[807]-work.L[984]*work.v[808])*work.d_inv[810];
work.L[991] = (-work.L[989]*work.v[807]-work.L[990]*work.v[808])*work.d_inv[810];
work.L[1001] = (-work.L[999]*work.v[808]-work.L[1000]*work.v[809])*work.d_inv[810];
work.L[1007] = (-work.L[1006]*work.v[809])*work.d_inv[810];
work.v[811] = 0;
work.d[811] = work.v[811];
if (work.d[811] > 0)
work.d[811] = -settings.kkt_reg;
else
work.d[811] -= settings.kkt_reg;
work.d_inv[811] = 1/work.d[811];
work.L[986] = (work.KKT[1669])*work.d_inv[811];
work.L[1008] = (work.KKT[1670])*work.d_inv[811];
work.L[1015] = (work.KKT[1671])*work.d_inv[811];
work.v[554] = work.L[979]*work.d[554];
work.v[555] = work.L[980]*work.d[555];
work.v[805] = work.L[981]*work.d[805];
work.v[806] = work.L[982]*work.d[806];
work.v[807] = work.L[983]*work.d[807];
work.v[808] = work.L[984]*work.d[808];
work.v[810] = work.L[985]*work.d[810];
work.v[811] = work.L[986]*work.d[811];
work.v[812] = work.KKT[1672]-work.L[979]*work.v[554]-work.L[980]*work.v[555]-work.L[981]*work.v[805]-work.L[982]*work.v[806]-work.L[983]*work.v[807]-work.L[984]*work.v[808]-work.L[985]*work.v[810]-work.L[986]*work.v[811];
work.d[812] = work.v[812];
if (work.d[812] < 0)
work.d[812] = settings.kkt_reg;
else
work.d[812] += settings.kkt_reg;
work.d_inv[812] = 1/work.d[812];
work.L[992] = (work.KKT[1673]-work.L[989]*work.v[807]-work.L[990]*work.v[808]-work.L[991]*work.v[810])*work.d_inv[812];
work.L[1002] = (-work.L[999]*work.v[808]-work.L[1001]*work.v[810])*work.d_inv[812];
work.L[1009] = (-work.L[1007]*work.v[810]-work.L[1008]*work.v[811])*work.d_inv[812];
work.L[1016] = (-work.L[1015]*work.v[811])*work.d_inv[812];
work.v[748] = work.L[987]*work.d[748];
work.v[749] = work.L[988]*work.d[749];
work.v[807] = work.L[989]*work.d[807];
work.v[808] = work.L[990]*work.d[808];
work.v[810] = work.L[991]*work.d[810];
work.v[812] = work.L[992]*work.d[812];
work.v[813] = 0-work.L[987]*work.v[748]-work.L[988]*work.v[749]-work.L[989]*work.v[807]-work.L[990]*work.v[808]-work.L[991]*work.v[810]-work.L[992]*work.v[812];
work.d[813] = work.v[813];
if (work.d[813] > 0)
work.d[813] = -settings.kkt_reg;
else
work.d[813] -= settings.kkt_reg;
work.d_inv[813] = 1/work.d[813];
work.L[1003] = (-work.L[999]*work.v[808]-work.L[1001]*work.v[810]-work.L[1002]*work.v[812])*work.d_inv[813];
work.L[1010] = (-work.L[1007]*work.v[810]-work.L[1009]*work.v[812])*work.d_inv[813];
work.L[1017] = (-work.L[1016]*work.v[812])*work.d_inv[813];
work.L[1023] = (-work.L[1021]*work.v[749])*work.d_inv[813];
work.v[346] = work.L[993]*work.d[346];
work.v[347] = work.L[994]*work.d[347];
work.v[450] = work.L[995]*work.d[450];
work.v[451] = work.L[996]*work.d[451];
work.v[454] = work.L[997]*work.d[454];
work.v[455] = work.L[998]*work.d[455];
work.v[808] = work.L[999]*work.d[808];
work.v[809] = work.L[1000]*work.d[809];
work.v[810] = work.L[1001]*work.d[810];
work.v[812] = work.L[1002]*work.d[812];
work.v[813] = work.L[1003]*work.d[813];
work.v[814] = 0-work.L[993]*work.v[346]-work.L[994]*work.v[347]-work.L[995]*work.v[450]-work.L[996]*work.v[451]-work.L[997]*work.v[454]-work.L[998]*work.v[455]-work.L[999]*work.v[808]-work.L[1000]*work.v[809]-work.L[1001]*work.v[810]-work.L[1002]*work.v[812]-work.L[1003]*work.v[813];
work.d[814] = work.v[814];
if (work.d[814] < 0)
work.d[814] = settings.kkt_reg;
else
work.d[814] += settings.kkt_reg;
work.d_inv[814] = 1/work.d[814];
work.L[1011] = (-work.L[1006]*work.v[809]-work.L[1007]*work.v[810]-work.L[1009]*work.v[812]-work.L[1010]*work.v[813])*work.d_inv[814];
work.L[1018] = (-work.L[1016]*work.v[812]-work.L[1017]*work.v[813])*work.d_inv[814];
work.L[1024] = (-work.L[1023]*work.v[813])*work.d_inv[814];
work.L[1033] = (-work.L[1029]*work.v[454]-work.L[1030]*work.v[455])*work.d_inv[814];
work.v[815] = 0;
work.d[815] = work.v[815];
if (work.d[815] > 0)
work.d[815] = -settings.kkt_reg;
else
work.d[815] -= settings.kkt_reg;
work.d_inv[815] = 1/work.d[815];
work.L[1012] = (work.KKT[1674])*work.d_inv[815];
work.L[1034] = (work.KKT[1675])*work.d_inv[815];
work.L[1040] = (work.KKT[1676])*work.d_inv[815];
work.v[659] = work.L[1004]*work.d[659];
work.v[660] = work.L[1005]*work.d[660];
work.v[809] = work.L[1006]*work.d[809];
work.v[810] = work.L[1007]*work.d[810];
work.v[811] = work.L[1008]*work.d[811];
work.v[812] = work.L[1009]*work.d[812];
work.v[813] = work.L[1010]*work.d[813];
work.v[814] = work.L[1011]*work.d[814];
work.v[815] = work.L[1012]*work.d[815];
work.v[816] = work.KKT[1677]-work.L[1004]*work.v[659]-work.L[1005]*work.v[660]-work.L[1006]*work.v[809]-work.L[1007]*work.v[810]-work.L[1008]*work.v[811]-work.L[1009]*work.v[812]-work.L[1010]*work.v[813]-work.L[1011]*work.v[814]-work.L[1012]*work.v[815];
work.d[816] = work.v[816];
if (work.d[816] < 0)
work.d[816] = settings.kkt_reg;
else
work.d[816] += settings.kkt_reg;
work.d_inv[816] = 1/work.d[816];
work.L[1019] = (-work.L[1015]*work.v[811]-work.L[1016]*work.v[812]-work.L[1017]*work.v[813]-work.L[1018]*work.v[814])*work.d_inv[816];
work.L[1025] = (-work.L[1023]*work.v[813]-work.L[1024]*work.v[814])*work.d_inv[816];
work.L[1035] = (-work.L[1033]*work.v[814]-work.L[1034]*work.v[815])*work.d_inv[816];
work.L[1041] = (-work.L[1040]*work.v[815])*work.d_inv[816];
work.v[817] = 0;
work.d[817] = work.v[817];
if (work.d[817] > 0)
work.d[817] = -settings.kkt_reg;
else
work.d[817] -= settings.kkt_reg;
work.d_inv[817] = 1/work.d[817];
work.L[1020] = (work.KKT[1678])*work.d_inv[817];
work.L[1042] = (work.KKT[1679])*work.d_inv[817];
work.L[1049] = (work.KKT[1680])*work.d_inv[817];
work.v[558] = work.L[1013]*work.d[558];
work.v[559] = work.L[1014]*work.d[559];
work.v[811] = work.L[1015]*work.d[811];
work.v[812] = work.L[1016]*work.d[812];
work.v[813] = work.L[1017]*work.d[813];
work.v[814] = work.L[1018]*work.d[814];
work.v[816] = work.L[1019]*work.d[816];
work.v[817] = work.L[1020]*work.d[817];
work.v[818] = work.KKT[1681]-work.L[1013]*work.v[558]-work.L[1014]*work.v[559]-work.L[1015]*work.v[811]-work.L[1016]*work.v[812]-work.L[1017]*work.v[813]-work.L[1018]*work.v[814]-work.L[1019]*work.v[816]-work.L[1020]*work.v[817];
work.d[818] = work.v[818];
if (work.d[818] < 0)
work.d[818] = settings.kkt_reg;
else
work.d[818] += settings.kkt_reg;
work.d_inv[818] = 1/work.d[818];
work.L[1026] = (work.KKT[1682]-work.L[1023]*work.v[813]-work.L[1024]*work.v[814]-work.L[1025]*work.v[816])*work.d_inv[818];
work.L[1036] = (-work.L[1033]*work.v[814]-work.L[1035]*work.v[816])*work.d_inv[818];
work.L[1043] = (-work.L[1041]*work.v[816]-work.L[1042]*work.v[817])*work.d_inv[818];
work.L[1050] = (-work.L[1049]*work.v[817])*work.d_inv[818];
work.v[749] = work.L[1021]*work.d[749];
work.v[750] = work.L[1022]*work.d[750];
work.v[813] = work.L[1023]*work.d[813];
work.v[814] = work.L[1024]*work.d[814];
work.v[816] = work.L[1025]*work.d[816];
work.v[818] = work.L[1026]*work.d[818];
work.v[819] = 0-work.L[1021]*work.v[749]-work.L[1022]*work.v[750]-work.L[1023]*work.v[813]-work.L[1024]*work.v[814]-work.L[1025]*work.v[816]-work.L[1026]*work.v[818];
work.d[819] = work.v[819];
if (work.d[819] > 0)
work.d[819] = -settings.kkt_reg;
else
work.d[819] -= settings.kkt_reg;
work.d_inv[819] = 1/work.d[819];
work.L[1037] = (-work.L[1033]*work.v[814]-work.L[1035]*work.v[816]-work.L[1036]*work.v[818])*work.d_inv[819];
work.L[1044] = (-work.L[1041]*work.v[816]-work.L[1043]*work.v[818])*work.d_inv[819];
work.L[1051] = (-work.L[1050]*work.v[818])*work.d_inv[819];
work.L[1057] = (-work.L[1055]*work.v[750])*work.d_inv[819];
work.v[350] = work.L[1027]*work.d[350];
work.v[351] = work.L[1028]*work.d[351];
work.v[454] = work.L[1029]*work.d[454];
work.v[455] = work.L[1030]*work.d[455];
work.v[458] = work.L[1031]*work.d[458];
work.v[459] = work.L[1032]*work.d[459];
work.v[814] = work.L[1033]*work.d[814];
work.v[815] = work.L[1034]*work.d[815];
work.v[816] = work.L[1035]*work.d[816];
work.v[818] = work.L[1036]*work.d[818];
work.v[819] = work.L[1037]*work.d[819];
work.v[820] = 0-work.L[1027]*work.v[350]-work.L[1028]*work.v[351]-work.L[1029]*work.v[454]-work.L[1030]*work.v[455]-work.L[1031]*work.v[458]-work.L[1032]*work.v[459]-work.L[1033]*work.v[814]-work.L[1034]*work.v[815]-work.L[1035]*work.v[816]-work.L[1036]*work.v[818]-work.L[1037]*work.v[819];
work.d[820] = work.v[820];
if (work.d[820] < 0)
work.d[820] = settings.kkt_reg;
else
work.d[820] += settings.kkt_reg;
work.d_inv[820] = 1/work.d[820];
work.L[1045] = (-work.L[1040]*work.v[815]-work.L[1041]*work.v[816]-work.L[1043]*work.v[818]-work.L[1044]*work.v[819])*work.d_inv[820];
work.L[1052] = (-work.L[1050]*work.v[818]-work.L[1051]*work.v[819])*work.d_inv[820];
work.L[1058] = (-work.L[1057]*work.v[819])*work.d_inv[820];
work.L[1067] = (-work.L[1063]*work.v[458]-work.L[1064]*work.v[459])*work.d_inv[820];
work.v[821] = 0;
work.d[821] = work.v[821];
if (work.d[821] > 0)
work.d[821] = -settings.kkt_reg;
else
work.d[821] -= settings.kkt_reg;
work.d_inv[821] = 1/work.d[821];
work.L[1046] = (work.KKT[1683])*work.d_inv[821];
work.L[1068] = (work.KKT[1684])*work.d_inv[821];
work.L[1074] = (work.KKT[1685])*work.d_inv[821];
work.v[663] = work.L[1038]*work.d[663];
work.v[664] = work.L[1039]*work.d[664];
work.v[815] = work.L[1040]*work.d[815];
work.v[816] = work.L[1041]*work.d[816];
work.v[817] = work.L[1042]*work.d[817];
work.v[818] = work.L[1043]*work.d[818];
work.v[819] = work.L[1044]*work.d[819];
work.v[820] = work.L[1045]*work.d[820];
work.v[821] = work.L[1046]*work.d[821];
work.v[822] = work.KKT[1686]-work.L[1038]*work.v[663]-work.L[1039]*work.v[664]-work.L[1040]*work.v[815]-work.L[1041]*work.v[816]-work.L[1042]*work.v[817]-work.L[1043]*work.v[818]-work.L[1044]*work.v[819]-work.L[1045]*work.v[820]-work.L[1046]*work.v[821];
work.d[822] = work.v[822];
if (work.d[822] < 0)
work.d[822] = settings.kkt_reg;
else
work.d[822] += settings.kkt_reg;
work.d_inv[822] = 1/work.d[822];
work.L[1053] = (-work.L[1049]*work.v[817]-work.L[1050]*work.v[818]-work.L[1051]*work.v[819]-work.L[1052]*work.v[820])*work.d_inv[822];
work.L[1059] = (-work.L[1057]*work.v[819]-work.L[1058]*work.v[820])*work.d_inv[822];
work.L[1069] = (-work.L[1067]*work.v[820]-work.L[1068]*work.v[821])*work.d_inv[822];
work.L[1075] = (-work.L[1074]*work.v[821])*work.d_inv[822];
work.v[823] = 0;
work.d[823] = work.v[823];
if (work.d[823] > 0)
work.d[823] = -settings.kkt_reg;
else
work.d[823] -= settings.kkt_reg;
work.d_inv[823] = 1/work.d[823];
work.L[1054] = (work.KKT[1687])*work.d_inv[823];
work.L[1076] = (work.KKT[1688])*work.d_inv[823];
work.L[1083] = (work.KKT[1689])*work.d_inv[823];
work.v[562] = work.L[1047]*work.d[562];
work.v[563] = work.L[1048]*work.d[563];
work.v[817] = work.L[1049]*work.d[817];
work.v[818] = work.L[1050]*work.d[818];
work.v[819] = work.L[1051]*work.d[819];
work.v[820] = work.L[1052]*work.d[820];
work.v[822] = work.L[1053]*work.d[822];
work.v[823] = work.L[1054]*work.d[823];
work.v[824] = work.KKT[1690]-work.L[1047]*work.v[562]-work.L[1048]*work.v[563]-work.L[1049]*work.v[817]-work.L[1050]*work.v[818]-work.L[1051]*work.v[819]-work.L[1052]*work.v[820]-work.L[1053]*work.v[822]-work.L[1054]*work.v[823];
work.d[824] = work.v[824];
if (work.d[824] < 0)
work.d[824] = settings.kkt_reg;
else
work.d[824] += settings.kkt_reg;
work.d_inv[824] = 1/work.d[824];
work.L[1060] = (work.KKT[1691]-work.L[1057]*work.v[819]-work.L[1058]*work.v[820]-work.L[1059]*work.v[822])*work.d_inv[824];
work.L[1070] = (-work.L[1067]*work.v[820]-work.L[1069]*work.v[822])*work.d_inv[824];
work.L[1077] = (-work.L[1075]*work.v[822]-work.L[1076]*work.v[823])*work.d_inv[824];
work.L[1084] = (-work.L[1083]*work.v[823])*work.d_inv[824];
work.v[750] = work.L[1055]*work.d[750];
work.v[751] = work.L[1056]*work.d[751];
work.v[819] = work.L[1057]*work.d[819];
work.v[820] = work.L[1058]*work.d[820];
work.v[822] = work.L[1059]*work.d[822];
work.v[824] = work.L[1060]*work.d[824];
work.v[825] = 0-work.L[1055]*work.v[750]-work.L[1056]*work.v[751]-work.L[1057]*work.v[819]-work.L[1058]*work.v[820]-work.L[1059]*work.v[822]-work.L[1060]*work.v[824];
work.d[825] = work.v[825];
if (work.d[825] > 0)
work.d[825] = -settings.kkt_reg;
else
work.d[825] -= settings.kkt_reg;
work.d_inv[825] = 1/work.d[825];
work.L[1071] = (-work.L[1067]*work.v[820]-work.L[1069]*work.v[822]-work.L[1070]*work.v[824])*work.d_inv[825];
work.L[1078] = (-work.L[1075]*work.v[822]-work.L[1077]*work.v[824])*work.d_inv[825];
work.L[1085] = (-work.L[1084]*work.v[824])*work.d_inv[825];
work.L[1091] = (-work.L[1089]*work.v[751])*work.d_inv[825];
work.v[354] = work.L[1061]*work.d[354];
work.v[355] = work.L[1062]*work.d[355];
work.v[458] = work.L[1063]*work.d[458];
work.v[459] = work.L[1064]*work.d[459];
work.v[462] = work.L[1065]*work.d[462];
work.v[463] = work.L[1066]*work.d[463];
work.v[820] = work.L[1067]*work.d[820];
work.v[821] = work.L[1068]*work.d[821];
work.v[822] = work.L[1069]*work.d[822];
work.v[824] = work.L[1070]*work.d[824];
work.v[825] = work.L[1071]*work.d[825];
work.v[826] = 0-work.L[1061]*work.v[354]-work.L[1062]*work.v[355]-work.L[1063]*work.v[458]-work.L[1064]*work.v[459]-work.L[1065]*work.v[462]-work.L[1066]*work.v[463]-work.L[1067]*work.v[820]-work.L[1068]*work.v[821]-work.L[1069]*work.v[822]-work.L[1070]*work.v[824]-work.L[1071]*work.v[825];
work.d[826] = work.v[826];
if (work.d[826] < 0)
work.d[826] = settings.kkt_reg;
else
work.d[826] += settings.kkt_reg;
work.d_inv[826] = 1/work.d[826];
work.L[1079] = (-work.L[1074]*work.v[821]-work.L[1075]*work.v[822]-work.L[1077]*work.v[824]-work.L[1078]*work.v[825])*work.d_inv[826];
work.L[1086] = (-work.L[1084]*work.v[824]-work.L[1085]*work.v[825])*work.d_inv[826];
work.L[1092] = (-work.L[1091]*work.v[825])*work.d_inv[826];
work.L[1101] = (-work.L[1097]*work.v[462]-work.L[1098]*work.v[463])*work.d_inv[826];
work.v[827] = 0;
work.d[827] = work.v[827];
if (work.d[827] > 0)
work.d[827] = -settings.kkt_reg;
else
work.d[827] -= settings.kkt_reg;
work.d_inv[827] = 1/work.d[827];
work.L[1080] = (work.KKT[1692])*work.d_inv[827];
work.L[1102] = (work.KKT[1693])*work.d_inv[827];
work.L[1108] = (work.KKT[1694])*work.d_inv[827];
work.v[667] = work.L[1072]*work.d[667];
work.v[668] = work.L[1073]*work.d[668];
work.v[821] = work.L[1074]*work.d[821];
work.v[822] = work.L[1075]*work.d[822];
work.v[823] = work.L[1076]*work.d[823];
work.v[824] = work.L[1077]*work.d[824];
work.v[825] = work.L[1078]*work.d[825];
work.v[826] = work.L[1079]*work.d[826];
work.v[827] = work.L[1080]*work.d[827];
work.v[828] = work.KKT[1695]-work.L[1072]*work.v[667]-work.L[1073]*work.v[668]-work.L[1074]*work.v[821]-work.L[1075]*work.v[822]-work.L[1076]*work.v[823]-work.L[1077]*work.v[824]-work.L[1078]*work.v[825]-work.L[1079]*work.v[826]-work.L[1080]*work.v[827];
work.d[828] = work.v[828];
if (work.d[828] < 0)
work.d[828] = settings.kkt_reg;
else
work.d[828] += settings.kkt_reg;
work.d_inv[828] = 1/work.d[828];
work.L[1087] = (-work.L[1083]*work.v[823]-work.L[1084]*work.v[824]-work.L[1085]*work.v[825]-work.L[1086]*work.v[826])*work.d_inv[828];
work.L[1093] = (-work.L[1091]*work.v[825]-work.L[1092]*work.v[826])*work.d_inv[828];
work.L[1103] = (-work.L[1101]*work.v[826]-work.L[1102]*work.v[827])*work.d_inv[828];
work.L[1109] = (-work.L[1108]*work.v[827])*work.d_inv[828];
work.v[829] = 0;
work.d[829] = work.v[829];
if (work.d[829] > 0)
work.d[829] = -settings.kkt_reg;
else
work.d[829] -= settings.kkt_reg;
work.d_inv[829] = 1/work.d[829];
work.L[1088] = (work.KKT[1696])*work.d_inv[829];
work.L[1110] = (work.KKT[1697])*work.d_inv[829];
work.L[1117] = (work.KKT[1698])*work.d_inv[829];
work.v[566] = work.L[1081]*work.d[566];
work.v[567] = work.L[1082]*work.d[567];
work.v[823] = work.L[1083]*work.d[823];
work.v[824] = work.L[1084]*work.d[824];
work.v[825] = work.L[1085]*work.d[825];
work.v[826] = work.L[1086]*work.d[826];
work.v[828] = work.L[1087]*work.d[828];
work.v[829] = work.L[1088]*work.d[829];
work.v[830] = work.KKT[1699]-work.L[1081]*work.v[566]-work.L[1082]*work.v[567]-work.L[1083]*work.v[823]-work.L[1084]*work.v[824]-work.L[1085]*work.v[825]-work.L[1086]*work.v[826]-work.L[1087]*work.v[828]-work.L[1088]*work.v[829];
work.d[830] = work.v[830];
if (work.d[830] < 0)
work.d[830] = settings.kkt_reg;
else
work.d[830] += settings.kkt_reg;
work.d_inv[830] = 1/work.d[830];
work.L[1094] = (work.KKT[1700]-work.L[1091]*work.v[825]-work.L[1092]*work.v[826]-work.L[1093]*work.v[828])*work.d_inv[830];
work.L[1104] = (-work.L[1101]*work.v[826]-work.L[1103]*work.v[828])*work.d_inv[830];
work.L[1111] = (-work.L[1109]*work.v[828]-work.L[1110]*work.v[829])*work.d_inv[830];
work.L[1118] = (-work.L[1117]*work.v[829])*work.d_inv[830];
work.v[751] = work.L[1089]*work.d[751];
work.v[752] = work.L[1090]*work.d[752];
work.v[825] = work.L[1091]*work.d[825];
work.v[826] = work.L[1092]*work.d[826];
work.v[828] = work.L[1093]*work.d[828];
work.v[830] = work.L[1094]*work.d[830];
work.v[831] = 0-work.L[1089]*work.v[751]-work.L[1090]*work.v[752]-work.L[1091]*work.v[825]-work.L[1092]*work.v[826]-work.L[1093]*work.v[828]-work.L[1094]*work.v[830];
work.d[831] = work.v[831];
if (work.d[831] > 0)
work.d[831] = -settings.kkt_reg;
else
work.d[831] -= settings.kkt_reg;
work.d_inv[831] = 1/work.d[831];
work.L[1105] = (-work.L[1101]*work.v[826]-work.L[1103]*work.v[828]-work.L[1104]*work.v[830])*work.d_inv[831];
work.L[1112] = (-work.L[1109]*work.v[828]-work.L[1111]*work.v[830])*work.d_inv[831];
work.L[1119] = (-work.L[1118]*work.v[830])*work.d_inv[831];
work.L[1125] = (-work.L[1123]*work.v[752])*work.d_inv[831];
work.v[358] = work.L[1095]*work.d[358];
work.v[359] = work.L[1096]*work.d[359];
work.v[462] = work.L[1097]*work.d[462];
work.v[463] = work.L[1098]*work.d[463];
work.v[466] = work.L[1099]*work.d[466];
work.v[467] = work.L[1100]*work.d[467];
work.v[826] = work.L[1101]*work.d[826];
work.v[827] = work.L[1102]*work.d[827];
work.v[828] = work.L[1103]*work.d[828];
work.v[830] = work.L[1104]*work.d[830];
work.v[831] = work.L[1105]*work.d[831];
work.v[832] = 0-work.L[1095]*work.v[358]-work.L[1096]*work.v[359]-work.L[1097]*work.v[462]-work.L[1098]*work.v[463]-work.L[1099]*work.v[466]-work.L[1100]*work.v[467]-work.L[1101]*work.v[826]-work.L[1102]*work.v[827]-work.L[1103]*work.v[828]-work.L[1104]*work.v[830]-work.L[1105]*work.v[831];
work.d[832] = work.v[832];
if (work.d[832] < 0)
work.d[832] = settings.kkt_reg;
else
work.d[832] += settings.kkt_reg;
work.d_inv[832] = 1/work.d[832];
work.L[1113] = (-work.L[1108]*work.v[827]-work.L[1109]*work.v[828]-work.L[1111]*work.v[830]-work.L[1112]*work.v[831])*work.d_inv[832];
work.L[1120] = (-work.L[1118]*work.v[830]-work.L[1119]*work.v[831])*work.d_inv[832];
work.L[1126] = (-work.L[1125]*work.v[831])*work.d_inv[832];
work.L[1135] = (-work.L[1131]*work.v[466]-work.L[1132]*work.v[467])*work.d_inv[832];
work.v[833] = 0;
work.d[833] = work.v[833];
if (work.d[833] > 0)
work.d[833] = -settings.kkt_reg;
else
work.d[833] -= settings.kkt_reg;
work.d_inv[833] = 1/work.d[833];
work.L[1114] = (work.KKT[1701])*work.d_inv[833];
work.L[1136] = (work.KKT[1702])*work.d_inv[833];
work.L[1142] = (work.KKT[1703])*work.d_inv[833];
work.v[671] = work.L[1106]*work.d[671];
work.v[672] = work.L[1107]*work.d[672];
work.v[827] = work.L[1108]*work.d[827];
work.v[828] = work.L[1109]*work.d[828];
work.v[829] = work.L[1110]*work.d[829];
work.v[830] = work.L[1111]*work.d[830];
work.v[831] = work.L[1112]*work.d[831];
work.v[832] = work.L[1113]*work.d[832];
work.v[833] = work.L[1114]*work.d[833];
work.v[834] = work.KKT[1704]-work.L[1106]*work.v[671]-work.L[1107]*work.v[672]-work.L[1108]*work.v[827]-work.L[1109]*work.v[828]-work.L[1110]*work.v[829]-work.L[1111]*work.v[830]-work.L[1112]*work.v[831]-work.L[1113]*work.v[832]-work.L[1114]*work.v[833];
work.d[834] = work.v[834];
if (work.d[834] < 0)
work.d[834] = settings.kkt_reg;
else
work.d[834] += settings.kkt_reg;
work.d_inv[834] = 1/work.d[834];
work.L[1121] = (-work.L[1117]*work.v[829]-work.L[1118]*work.v[830]-work.L[1119]*work.v[831]-work.L[1120]*work.v[832])*work.d_inv[834];
work.L[1127] = (-work.L[1125]*work.v[831]-work.L[1126]*work.v[832])*work.d_inv[834];
work.L[1137] = (-work.L[1135]*work.v[832]-work.L[1136]*work.v[833])*work.d_inv[834];
work.L[1143] = (-work.L[1142]*work.v[833])*work.d_inv[834];
work.v[835] = 0;
work.d[835] = work.v[835];
if (work.d[835] > 0)
work.d[835] = -settings.kkt_reg;
else
work.d[835] -= settings.kkt_reg;
work.d_inv[835] = 1/work.d[835];
work.L[1122] = (work.KKT[1705])*work.d_inv[835];
work.L[1144] = (work.KKT[1706])*work.d_inv[835];
work.L[1151] = (work.KKT[1707])*work.d_inv[835];
work.v[570] = work.L[1115]*work.d[570];
work.v[571] = work.L[1116]*work.d[571];
work.v[829] = work.L[1117]*work.d[829];
work.v[830] = work.L[1118]*work.d[830];
work.v[831] = work.L[1119]*work.d[831];
work.v[832] = work.L[1120]*work.d[832];
work.v[834] = work.L[1121]*work.d[834];
work.v[835] = work.L[1122]*work.d[835];
work.v[836] = work.KKT[1708]-work.L[1115]*work.v[570]-work.L[1116]*work.v[571]-work.L[1117]*work.v[829]-work.L[1118]*work.v[830]-work.L[1119]*work.v[831]-work.L[1120]*work.v[832]-work.L[1121]*work.v[834]-work.L[1122]*work.v[835];
work.d[836] = work.v[836];
if (work.d[836] < 0)
work.d[836] = settings.kkt_reg;
else
work.d[836] += settings.kkt_reg;
work.d_inv[836] = 1/work.d[836];
work.L[1128] = (work.KKT[1709]-work.L[1125]*work.v[831]-work.L[1126]*work.v[832]-work.L[1127]*work.v[834])*work.d_inv[836];
work.L[1138] = (-work.L[1135]*work.v[832]-work.L[1137]*work.v[834])*work.d_inv[836];
work.L[1145] = (-work.L[1143]*work.v[834]-work.L[1144]*work.v[835])*work.d_inv[836];
work.L[1152] = (-work.L[1151]*work.v[835])*work.d_inv[836];
work.v[752] = work.L[1123]*work.d[752];
work.v[753] = work.L[1124]*work.d[753];
work.v[831] = work.L[1125]*work.d[831];
work.v[832] = work.L[1126]*work.d[832];
work.v[834] = work.L[1127]*work.d[834];
work.v[836] = work.L[1128]*work.d[836];
work.v[837] = 0-work.L[1123]*work.v[752]-work.L[1124]*work.v[753]-work.L[1125]*work.v[831]-work.L[1126]*work.v[832]-work.L[1127]*work.v[834]-work.L[1128]*work.v[836];
work.d[837] = work.v[837];
if (work.d[837] > 0)
work.d[837] = -settings.kkt_reg;
else
work.d[837] -= settings.kkt_reg;
work.d_inv[837] = 1/work.d[837];
work.L[1139] = (-work.L[1135]*work.v[832]-work.L[1137]*work.v[834]-work.L[1138]*work.v[836])*work.d_inv[837];
work.L[1146] = (-work.L[1143]*work.v[834]-work.L[1145]*work.v[836])*work.d_inv[837];
work.L[1153] = (-work.L[1152]*work.v[836])*work.d_inv[837];
work.L[1159] = (-work.L[1157]*work.v[753])*work.d_inv[837];
work.v[362] = work.L[1129]*work.d[362];
work.v[363] = work.L[1130]*work.d[363];
work.v[466] = work.L[1131]*work.d[466];
work.v[467] = work.L[1132]*work.d[467];
work.v[470] = work.L[1133]*work.d[470];
work.v[471] = work.L[1134]*work.d[471];
work.v[832] = work.L[1135]*work.d[832];
work.v[833] = work.L[1136]*work.d[833];
work.v[834] = work.L[1137]*work.d[834];
work.v[836] = work.L[1138]*work.d[836];
work.v[837] = work.L[1139]*work.d[837];
work.v[838] = 0-work.L[1129]*work.v[362]-work.L[1130]*work.v[363]-work.L[1131]*work.v[466]-work.L[1132]*work.v[467]-work.L[1133]*work.v[470]-work.L[1134]*work.v[471]-work.L[1135]*work.v[832]-work.L[1136]*work.v[833]-work.L[1137]*work.v[834]-work.L[1138]*work.v[836]-work.L[1139]*work.v[837];
work.d[838] = work.v[838];
if (work.d[838] < 0)
work.d[838] = settings.kkt_reg;
else
work.d[838] += settings.kkt_reg;
work.d_inv[838] = 1/work.d[838];
work.L[1147] = (-work.L[1142]*work.v[833]-work.L[1143]*work.v[834]-work.L[1145]*work.v[836]-work.L[1146]*work.v[837])*work.d_inv[838];
work.L[1154] = (-work.L[1152]*work.v[836]-work.L[1153]*work.v[837])*work.d_inv[838];
work.L[1160] = (-work.L[1159]*work.v[837])*work.d_inv[838];
work.L[1169] = (-work.L[1165]*work.v[470]-work.L[1166]*work.v[471])*work.d_inv[838];
work.v[839] = 0;
work.d[839] = work.v[839];
if (work.d[839] > 0)
work.d[839] = -settings.kkt_reg;
else
work.d[839] -= settings.kkt_reg;
work.d_inv[839] = 1/work.d[839];
work.L[1148] = (work.KKT[1710])*work.d_inv[839];
work.L[1170] = (work.KKT[1711])*work.d_inv[839];
work.L[1176] = (work.KKT[1712])*work.d_inv[839];
work.v[675] = work.L[1140]*work.d[675];
work.v[676] = work.L[1141]*work.d[676];
work.v[833] = work.L[1142]*work.d[833];
work.v[834] = work.L[1143]*work.d[834];
work.v[835] = work.L[1144]*work.d[835];
work.v[836] = work.L[1145]*work.d[836];
work.v[837] = work.L[1146]*work.d[837];
work.v[838] = work.L[1147]*work.d[838];
work.v[839] = work.L[1148]*work.d[839];
work.v[840] = work.KKT[1713]-work.L[1140]*work.v[675]-work.L[1141]*work.v[676]-work.L[1142]*work.v[833]-work.L[1143]*work.v[834]-work.L[1144]*work.v[835]-work.L[1145]*work.v[836]-work.L[1146]*work.v[837]-work.L[1147]*work.v[838]-work.L[1148]*work.v[839];
work.d[840] = work.v[840];
if (work.d[840] < 0)
work.d[840] = settings.kkt_reg;
else
work.d[840] += settings.kkt_reg;
work.d_inv[840] = 1/work.d[840];
work.L[1155] = (-work.L[1151]*work.v[835]-work.L[1152]*work.v[836]-work.L[1153]*work.v[837]-work.L[1154]*work.v[838])*work.d_inv[840];
work.L[1161] = (-work.L[1159]*work.v[837]-work.L[1160]*work.v[838])*work.d_inv[840];
work.L[1171] = (-work.L[1169]*work.v[838]-work.L[1170]*work.v[839])*work.d_inv[840];
work.L[1177] = (-work.L[1176]*work.v[839])*work.d_inv[840];
work.v[841] = 0;
work.d[841] = work.v[841];
if (work.d[841] > 0)
work.d[841] = -settings.kkt_reg;
else
work.d[841] -= settings.kkt_reg;
work.d_inv[841] = 1/work.d[841];
work.L[1156] = (work.KKT[1714])*work.d_inv[841];
work.L[1178] = (work.KKT[1715])*work.d_inv[841];
work.L[1185] = (work.KKT[1716])*work.d_inv[841];
work.v[574] = work.L[1149]*work.d[574];
work.v[575] = work.L[1150]*work.d[575];
work.v[835] = work.L[1151]*work.d[835];
work.v[836] = work.L[1152]*work.d[836];
work.v[837] = work.L[1153]*work.d[837];
work.v[838] = work.L[1154]*work.d[838];
work.v[840] = work.L[1155]*work.d[840];
work.v[841] = work.L[1156]*work.d[841];
work.v[842] = work.KKT[1717]-work.L[1149]*work.v[574]-work.L[1150]*work.v[575]-work.L[1151]*work.v[835]-work.L[1152]*work.v[836]-work.L[1153]*work.v[837]-work.L[1154]*work.v[838]-work.L[1155]*work.v[840]-work.L[1156]*work.v[841];
work.d[842] = work.v[842];
if (work.d[842] < 0)
work.d[842] = settings.kkt_reg;
else
work.d[842] += settings.kkt_reg;
work.d_inv[842] = 1/work.d[842];
work.L[1162] = (work.KKT[1718]-work.L[1159]*work.v[837]-work.L[1160]*work.v[838]-work.L[1161]*work.v[840])*work.d_inv[842];
work.L[1172] = (-work.L[1169]*work.v[838]-work.L[1171]*work.v[840])*work.d_inv[842];
work.L[1179] = (-work.L[1177]*work.v[840]-work.L[1178]*work.v[841])*work.d_inv[842];
work.L[1186] = (-work.L[1185]*work.v[841])*work.d_inv[842];
work.v[753] = work.L[1157]*work.d[753];
work.v[754] = work.L[1158]*work.d[754];
work.v[837] = work.L[1159]*work.d[837];
work.v[838] = work.L[1160]*work.d[838];
work.v[840] = work.L[1161]*work.d[840];
work.v[842] = work.L[1162]*work.d[842];
work.v[843] = 0-work.L[1157]*work.v[753]-work.L[1158]*work.v[754]-work.L[1159]*work.v[837]-work.L[1160]*work.v[838]-work.L[1161]*work.v[840]-work.L[1162]*work.v[842];
work.d[843] = work.v[843];
if (work.d[843] > 0)
work.d[843] = -settings.kkt_reg;
else
work.d[843] -= settings.kkt_reg;
work.d_inv[843] = 1/work.d[843];
work.L[1173] = (-work.L[1169]*work.v[838]-work.L[1171]*work.v[840]-work.L[1172]*work.v[842])*work.d_inv[843];
work.L[1180] = (-work.L[1177]*work.v[840]-work.L[1179]*work.v[842])*work.d_inv[843];
work.L[1187] = (-work.L[1186]*work.v[842])*work.d_inv[843];
work.L[1193] = (-work.L[1191]*work.v[754])*work.d_inv[843];
work.v[366] = work.L[1163]*work.d[366];
work.v[367] = work.L[1164]*work.d[367];
work.v[470] = work.L[1165]*work.d[470];
work.v[471] = work.L[1166]*work.d[471];
work.v[474] = work.L[1167]*work.d[474];
work.v[475] = work.L[1168]*work.d[475];
work.v[838] = work.L[1169]*work.d[838];
work.v[839] = work.L[1170]*work.d[839];
work.v[840] = work.L[1171]*work.d[840];
work.v[842] = work.L[1172]*work.d[842];
work.v[843] = work.L[1173]*work.d[843];
work.v[844] = 0-work.L[1163]*work.v[366]-work.L[1164]*work.v[367]-work.L[1165]*work.v[470]-work.L[1166]*work.v[471]-work.L[1167]*work.v[474]-work.L[1168]*work.v[475]-work.L[1169]*work.v[838]-work.L[1170]*work.v[839]-work.L[1171]*work.v[840]-work.L[1172]*work.v[842]-work.L[1173]*work.v[843];
work.d[844] = work.v[844];
if (work.d[844] < 0)
work.d[844] = settings.kkt_reg;
else
work.d[844] += settings.kkt_reg;
work.d_inv[844] = 1/work.d[844];
work.L[1181] = (-work.L[1176]*work.v[839]-work.L[1177]*work.v[840]-work.L[1179]*work.v[842]-work.L[1180]*work.v[843])*work.d_inv[844];
work.L[1188] = (-work.L[1186]*work.v[842]-work.L[1187]*work.v[843])*work.d_inv[844];
work.L[1194] = (-work.L[1193]*work.v[843])*work.d_inv[844];
work.L[1203] = (-work.L[1199]*work.v[474]-work.L[1200]*work.v[475])*work.d_inv[844];
work.v[845] = 0;
work.d[845] = work.v[845];
if (work.d[845] > 0)
work.d[845] = -settings.kkt_reg;
else
work.d[845] -= settings.kkt_reg;
work.d_inv[845] = 1/work.d[845];
work.L[1182] = (work.KKT[1719])*work.d_inv[845];
work.L[1204] = (work.KKT[1720])*work.d_inv[845];
work.L[1210] = (work.KKT[1721])*work.d_inv[845];
work.v[679] = work.L[1174]*work.d[679];
work.v[680] = work.L[1175]*work.d[680];
work.v[839] = work.L[1176]*work.d[839];
work.v[840] = work.L[1177]*work.d[840];
work.v[841] = work.L[1178]*work.d[841];
work.v[842] = work.L[1179]*work.d[842];
work.v[843] = work.L[1180]*work.d[843];
work.v[844] = work.L[1181]*work.d[844];
work.v[845] = work.L[1182]*work.d[845];
work.v[846] = work.KKT[1722]-work.L[1174]*work.v[679]-work.L[1175]*work.v[680]-work.L[1176]*work.v[839]-work.L[1177]*work.v[840]-work.L[1178]*work.v[841]-work.L[1179]*work.v[842]-work.L[1180]*work.v[843]-work.L[1181]*work.v[844]-work.L[1182]*work.v[845];
work.d[846] = work.v[846];
if (work.d[846] < 0)
work.d[846] = settings.kkt_reg;
else
work.d[846] += settings.kkt_reg;
work.d_inv[846] = 1/work.d[846];
work.L[1189] = (-work.L[1185]*work.v[841]-work.L[1186]*work.v[842]-work.L[1187]*work.v[843]-work.L[1188]*work.v[844])*work.d_inv[846];
work.L[1195] = (-work.L[1193]*work.v[843]-work.L[1194]*work.v[844])*work.d_inv[846];
work.L[1205] = (-work.L[1203]*work.v[844]-work.L[1204]*work.v[845])*work.d_inv[846];
work.L[1211] = (-work.L[1210]*work.v[845])*work.d_inv[846];
work.v[847] = 0;
work.d[847] = work.v[847];
if (work.d[847] > 0)
work.d[847] = -settings.kkt_reg;
else
work.d[847] -= settings.kkt_reg;
work.d_inv[847] = 1/work.d[847];
work.L[1190] = (work.KKT[1723])*work.d_inv[847];
work.L[1212] = (work.KKT[1724])*work.d_inv[847];
work.L[1219] = (work.KKT[1725])*work.d_inv[847];
work.v[578] = work.L[1183]*work.d[578];
work.v[579] = work.L[1184]*work.d[579];
work.v[841] = work.L[1185]*work.d[841];
work.v[842] = work.L[1186]*work.d[842];
work.v[843] = work.L[1187]*work.d[843];
work.v[844] = work.L[1188]*work.d[844];
work.v[846] = work.L[1189]*work.d[846];
work.v[847] = work.L[1190]*work.d[847];
work.v[848] = work.KKT[1726]-work.L[1183]*work.v[578]-work.L[1184]*work.v[579]-work.L[1185]*work.v[841]-work.L[1186]*work.v[842]-work.L[1187]*work.v[843]-work.L[1188]*work.v[844]-work.L[1189]*work.v[846]-work.L[1190]*work.v[847];
work.d[848] = work.v[848];
if (work.d[848] < 0)
work.d[848] = settings.kkt_reg;
else
work.d[848] += settings.kkt_reg;
work.d_inv[848] = 1/work.d[848];
work.L[1196] = (work.KKT[1727]-work.L[1193]*work.v[843]-work.L[1194]*work.v[844]-work.L[1195]*work.v[846])*work.d_inv[848];
work.L[1206] = (-work.L[1203]*work.v[844]-work.L[1205]*work.v[846])*work.d_inv[848];
work.L[1213] = (-work.L[1211]*work.v[846]-work.L[1212]*work.v[847])*work.d_inv[848];
work.L[1220] = (-work.L[1219]*work.v[847])*work.d_inv[848];
work.v[754] = work.L[1191]*work.d[754];
work.v[755] = work.L[1192]*work.d[755];
work.v[843] = work.L[1193]*work.d[843];
work.v[844] = work.L[1194]*work.d[844];
work.v[846] = work.L[1195]*work.d[846];
work.v[848] = work.L[1196]*work.d[848];
work.v[849] = 0-work.L[1191]*work.v[754]-work.L[1192]*work.v[755]-work.L[1193]*work.v[843]-work.L[1194]*work.v[844]-work.L[1195]*work.v[846]-work.L[1196]*work.v[848];
work.d[849] = work.v[849];
if (work.d[849] > 0)
work.d[849] = -settings.kkt_reg;
else
work.d[849] -= settings.kkt_reg;
work.d_inv[849] = 1/work.d[849];
work.L[1207] = (-work.L[1203]*work.v[844]-work.L[1205]*work.v[846]-work.L[1206]*work.v[848])*work.d_inv[849];
work.L[1214] = (-work.L[1211]*work.v[846]-work.L[1213]*work.v[848])*work.d_inv[849];
work.L[1221] = (-work.L[1220]*work.v[848])*work.d_inv[849];
work.L[1227] = (-work.L[1225]*work.v[755])*work.d_inv[849];
work.v[370] = work.L[1197]*work.d[370];
work.v[371] = work.L[1198]*work.d[371];
work.v[474] = work.L[1199]*work.d[474];
work.v[475] = work.L[1200]*work.d[475];
work.v[478] = work.L[1201]*work.d[478];
work.v[479] = work.L[1202]*work.d[479];
work.v[844] = work.L[1203]*work.d[844];
work.v[845] = work.L[1204]*work.d[845];
work.v[846] = work.L[1205]*work.d[846];
work.v[848] = work.L[1206]*work.d[848];
work.v[849] = work.L[1207]*work.d[849];
work.v[850] = 0-work.L[1197]*work.v[370]-work.L[1198]*work.v[371]-work.L[1199]*work.v[474]-work.L[1200]*work.v[475]-work.L[1201]*work.v[478]-work.L[1202]*work.v[479]-work.L[1203]*work.v[844]-work.L[1204]*work.v[845]-work.L[1205]*work.v[846]-work.L[1206]*work.v[848]-work.L[1207]*work.v[849];
work.d[850] = work.v[850];
if (work.d[850] < 0)
work.d[850] = settings.kkt_reg;
else
work.d[850] += settings.kkt_reg;
work.d_inv[850] = 1/work.d[850];
work.L[1215] = (-work.L[1210]*work.v[845]-work.L[1211]*work.v[846]-work.L[1213]*work.v[848]-work.L[1214]*work.v[849])*work.d_inv[850];
work.L[1222] = (-work.L[1220]*work.v[848]-work.L[1221]*work.v[849])*work.d_inv[850];
work.L[1228] = (-work.L[1227]*work.v[849])*work.d_inv[850];
work.L[1237] = (-work.L[1233]*work.v[478]-work.L[1234]*work.v[479])*work.d_inv[850];
work.v[851] = 0;
work.d[851] = work.v[851];
if (work.d[851] > 0)
work.d[851] = -settings.kkt_reg;
else
work.d[851] -= settings.kkt_reg;
work.d_inv[851] = 1/work.d[851];
work.L[1216] = (work.KKT[1728])*work.d_inv[851];
work.L[1238] = (work.KKT[1729])*work.d_inv[851];
work.L[1244] = (work.KKT[1730])*work.d_inv[851];
work.v[683] = work.L[1208]*work.d[683];
work.v[684] = work.L[1209]*work.d[684];
work.v[845] = work.L[1210]*work.d[845];
work.v[846] = work.L[1211]*work.d[846];
work.v[847] = work.L[1212]*work.d[847];
work.v[848] = work.L[1213]*work.d[848];
work.v[849] = work.L[1214]*work.d[849];
work.v[850] = work.L[1215]*work.d[850];
work.v[851] = work.L[1216]*work.d[851];
work.v[852] = work.KKT[1731]-work.L[1208]*work.v[683]-work.L[1209]*work.v[684]-work.L[1210]*work.v[845]-work.L[1211]*work.v[846]-work.L[1212]*work.v[847]-work.L[1213]*work.v[848]-work.L[1214]*work.v[849]-work.L[1215]*work.v[850]-work.L[1216]*work.v[851];
work.d[852] = work.v[852];
if (work.d[852] < 0)
work.d[852] = settings.kkt_reg;
else
work.d[852] += settings.kkt_reg;
work.d_inv[852] = 1/work.d[852];
work.L[1223] = (-work.L[1219]*work.v[847]-work.L[1220]*work.v[848]-work.L[1221]*work.v[849]-work.L[1222]*work.v[850])*work.d_inv[852];
work.L[1229] = (-work.L[1227]*work.v[849]-work.L[1228]*work.v[850])*work.d_inv[852];
work.L[1239] = (-work.L[1237]*work.v[850]-work.L[1238]*work.v[851])*work.d_inv[852];
work.L[1245] = (-work.L[1244]*work.v[851])*work.d_inv[852];
work.v[853] = 0;
work.d[853] = work.v[853];
if (work.d[853] > 0)
work.d[853] = -settings.kkt_reg;
else
work.d[853] -= settings.kkt_reg;
work.d_inv[853] = 1/work.d[853];
work.L[1224] = (work.KKT[1732])*work.d_inv[853];
work.L[1246] = (work.KKT[1733])*work.d_inv[853];
work.L[1253] = (work.KKT[1734])*work.d_inv[853];
work.v[582] = work.L[1217]*work.d[582];
work.v[583] = work.L[1218]*work.d[583];
work.v[847] = work.L[1219]*work.d[847];
work.v[848] = work.L[1220]*work.d[848];
work.v[849] = work.L[1221]*work.d[849];
work.v[850] = work.L[1222]*work.d[850];
work.v[852] = work.L[1223]*work.d[852];
work.v[853] = work.L[1224]*work.d[853];
work.v[854] = work.KKT[1735]-work.L[1217]*work.v[582]-work.L[1218]*work.v[583]-work.L[1219]*work.v[847]-work.L[1220]*work.v[848]-work.L[1221]*work.v[849]-work.L[1222]*work.v[850]-work.L[1223]*work.v[852]-work.L[1224]*work.v[853];
work.d[854] = work.v[854];
if (work.d[854] < 0)
work.d[854] = settings.kkt_reg;
else
work.d[854] += settings.kkt_reg;
work.d_inv[854] = 1/work.d[854];
work.L[1230] = (work.KKT[1736]-work.L[1227]*work.v[849]-work.L[1228]*work.v[850]-work.L[1229]*work.v[852])*work.d_inv[854];
work.L[1240] = (-work.L[1237]*work.v[850]-work.L[1239]*work.v[852])*work.d_inv[854];
work.L[1247] = (-work.L[1245]*work.v[852]-work.L[1246]*work.v[853])*work.d_inv[854];
work.L[1254] = (-work.L[1253]*work.v[853])*work.d_inv[854];
work.v[755] = work.L[1225]*work.d[755];
work.v[756] = work.L[1226]*work.d[756];
work.v[849] = work.L[1227]*work.d[849];
work.v[850] = work.L[1228]*work.d[850];
work.v[852] = work.L[1229]*work.d[852];
work.v[854] = work.L[1230]*work.d[854];
work.v[855] = 0-work.L[1225]*work.v[755]-work.L[1226]*work.v[756]-work.L[1227]*work.v[849]-work.L[1228]*work.v[850]-work.L[1229]*work.v[852]-work.L[1230]*work.v[854];
work.d[855] = work.v[855];
if (work.d[855] > 0)
work.d[855] = -settings.kkt_reg;
else
work.d[855] -= settings.kkt_reg;
work.d_inv[855] = 1/work.d[855];
work.L[1241] = (-work.L[1237]*work.v[850]-work.L[1239]*work.v[852]-work.L[1240]*work.v[854])*work.d_inv[855];
work.L[1248] = (-work.L[1245]*work.v[852]-work.L[1247]*work.v[854])*work.d_inv[855];
work.L[1255] = (-work.L[1254]*work.v[854])*work.d_inv[855];
work.L[1261] = (-work.L[1259]*work.v[756])*work.d_inv[855];
work.v[374] = work.L[1231]*work.d[374];
work.v[375] = work.L[1232]*work.d[375];
work.v[478] = work.L[1233]*work.d[478];
work.v[479] = work.L[1234]*work.d[479];
work.v[482] = work.L[1235]*work.d[482];
work.v[483] = work.L[1236]*work.d[483];
work.v[850] = work.L[1237]*work.d[850];
work.v[851] = work.L[1238]*work.d[851];
work.v[852] = work.L[1239]*work.d[852];
work.v[854] = work.L[1240]*work.d[854];
work.v[855] = work.L[1241]*work.d[855];
work.v[856] = 0-work.L[1231]*work.v[374]-work.L[1232]*work.v[375]-work.L[1233]*work.v[478]-work.L[1234]*work.v[479]-work.L[1235]*work.v[482]-work.L[1236]*work.v[483]-work.L[1237]*work.v[850]-work.L[1238]*work.v[851]-work.L[1239]*work.v[852]-work.L[1240]*work.v[854]-work.L[1241]*work.v[855];
work.d[856] = work.v[856];
if (work.d[856] < 0)
work.d[856] = settings.kkt_reg;
else
work.d[856] += settings.kkt_reg;
work.d_inv[856] = 1/work.d[856];
work.L[1249] = (-work.L[1244]*work.v[851]-work.L[1245]*work.v[852]-work.L[1247]*work.v[854]-work.L[1248]*work.v[855])*work.d_inv[856];
work.L[1256] = (-work.L[1254]*work.v[854]-work.L[1255]*work.v[855])*work.d_inv[856];
work.L[1262] = (-work.L[1261]*work.v[855])*work.d_inv[856];
work.L[1271] = (-work.L[1267]*work.v[482]-work.L[1268]*work.v[483])*work.d_inv[856];
work.v[857] = 0;
work.d[857] = work.v[857];
if (work.d[857] > 0)
work.d[857] = -settings.kkt_reg;
else
work.d[857] -= settings.kkt_reg;
work.d_inv[857] = 1/work.d[857];
work.L[1250] = (work.KKT[1737])*work.d_inv[857];
work.L[1272] = (work.KKT[1738])*work.d_inv[857];
work.L[1278] = (work.KKT[1739])*work.d_inv[857];
work.v[687] = work.L[1242]*work.d[687];
work.v[688] = work.L[1243]*work.d[688];
work.v[851] = work.L[1244]*work.d[851];
work.v[852] = work.L[1245]*work.d[852];
work.v[853] = work.L[1246]*work.d[853];
work.v[854] = work.L[1247]*work.d[854];
work.v[855] = work.L[1248]*work.d[855];
work.v[856] = work.L[1249]*work.d[856];
work.v[857] = work.L[1250]*work.d[857];
work.v[858] = work.KKT[1740]-work.L[1242]*work.v[687]-work.L[1243]*work.v[688]-work.L[1244]*work.v[851]-work.L[1245]*work.v[852]-work.L[1246]*work.v[853]-work.L[1247]*work.v[854]-work.L[1248]*work.v[855]-work.L[1249]*work.v[856]-work.L[1250]*work.v[857];
work.d[858] = work.v[858];
if (work.d[858] < 0)
work.d[858] = settings.kkt_reg;
else
work.d[858] += settings.kkt_reg;
work.d_inv[858] = 1/work.d[858];
work.L[1257] = (-work.L[1253]*work.v[853]-work.L[1254]*work.v[854]-work.L[1255]*work.v[855]-work.L[1256]*work.v[856])*work.d_inv[858];
work.L[1263] = (-work.L[1261]*work.v[855]-work.L[1262]*work.v[856])*work.d_inv[858];
work.L[1273] = (-work.L[1271]*work.v[856]-work.L[1272]*work.v[857])*work.d_inv[858];
work.L[1279] = (-work.L[1278]*work.v[857])*work.d_inv[858];
work.v[859] = 0;
work.d[859] = work.v[859];
if (work.d[859] > 0)
work.d[859] = -settings.kkt_reg;
else
work.d[859] -= settings.kkt_reg;
work.d_inv[859] = 1/work.d[859];
work.L[1258] = (work.KKT[1741])*work.d_inv[859];
work.L[1280] = (work.KKT[1742])*work.d_inv[859];
work.L[1287] = (work.KKT[1743])*work.d_inv[859];
work.v[586] = work.L[1251]*work.d[586];
work.v[587] = work.L[1252]*work.d[587];
work.v[853] = work.L[1253]*work.d[853];
work.v[854] = work.L[1254]*work.d[854];
work.v[855] = work.L[1255]*work.d[855];
work.v[856] = work.L[1256]*work.d[856];
work.v[858] = work.L[1257]*work.d[858];
work.v[859] = work.L[1258]*work.d[859];
work.v[860] = work.KKT[1744]-work.L[1251]*work.v[586]-work.L[1252]*work.v[587]-work.L[1253]*work.v[853]-work.L[1254]*work.v[854]-work.L[1255]*work.v[855]-work.L[1256]*work.v[856]-work.L[1257]*work.v[858]-work.L[1258]*work.v[859];
work.d[860] = work.v[860];
if (work.d[860] < 0)
work.d[860] = settings.kkt_reg;
else
work.d[860] += settings.kkt_reg;
work.d_inv[860] = 1/work.d[860];
work.L[1264] = (work.KKT[1745]-work.L[1261]*work.v[855]-work.L[1262]*work.v[856]-work.L[1263]*work.v[858])*work.d_inv[860];
work.L[1274] = (-work.L[1271]*work.v[856]-work.L[1273]*work.v[858])*work.d_inv[860];
work.L[1281] = (-work.L[1279]*work.v[858]-work.L[1280]*work.v[859])*work.d_inv[860];
work.L[1288] = (-work.L[1287]*work.v[859])*work.d_inv[860];
work.v[756] = work.L[1259]*work.d[756];
work.v[757] = work.L[1260]*work.d[757];
work.v[855] = work.L[1261]*work.d[855];
work.v[856] = work.L[1262]*work.d[856];
work.v[858] = work.L[1263]*work.d[858];
work.v[860] = work.L[1264]*work.d[860];
work.v[861] = 0-work.L[1259]*work.v[756]-work.L[1260]*work.v[757]-work.L[1261]*work.v[855]-work.L[1262]*work.v[856]-work.L[1263]*work.v[858]-work.L[1264]*work.v[860];
work.d[861] = work.v[861];
if (work.d[861] > 0)
work.d[861] = -settings.kkt_reg;
else
work.d[861] -= settings.kkt_reg;
work.d_inv[861] = 1/work.d[861];
work.L[1275] = (-work.L[1271]*work.v[856]-work.L[1273]*work.v[858]-work.L[1274]*work.v[860])*work.d_inv[861];
work.L[1282] = (-work.L[1279]*work.v[858]-work.L[1281]*work.v[860])*work.d_inv[861];
work.L[1289] = (-work.L[1288]*work.v[860])*work.d_inv[861];
work.L[1295] = (-work.L[1293]*work.v[757])*work.d_inv[861];
work.v[378] = work.L[1265]*work.d[378];
work.v[379] = work.L[1266]*work.d[379];
work.v[482] = work.L[1267]*work.d[482];
work.v[483] = work.L[1268]*work.d[483];
work.v[486] = work.L[1269]*work.d[486];
work.v[487] = work.L[1270]*work.d[487];
work.v[856] = work.L[1271]*work.d[856];
work.v[857] = work.L[1272]*work.d[857];
work.v[858] = work.L[1273]*work.d[858];
work.v[860] = work.L[1274]*work.d[860];
work.v[861] = work.L[1275]*work.d[861];
work.v[862] = 0-work.L[1265]*work.v[378]-work.L[1266]*work.v[379]-work.L[1267]*work.v[482]-work.L[1268]*work.v[483]-work.L[1269]*work.v[486]-work.L[1270]*work.v[487]-work.L[1271]*work.v[856]-work.L[1272]*work.v[857]-work.L[1273]*work.v[858]-work.L[1274]*work.v[860]-work.L[1275]*work.v[861];
work.d[862] = work.v[862];
if (work.d[862] < 0)
work.d[862] = settings.kkt_reg;
else
work.d[862] += settings.kkt_reg;
work.d_inv[862] = 1/work.d[862];
work.L[1283] = (-work.L[1278]*work.v[857]-work.L[1279]*work.v[858]-work.L[1281]*work.v[860]-work.L[1282]*work.v[861])*work.d_inv[862];
work.L[1290] = (-work.L[1288]*work.v[860]-work.L[1289]*work.v[861])*work.d_inv[862];
work.L[1296] = (-work.L[1295]*work.v[861])*work.d_inv[862];
work.L[1305] = (-work.L[1301]*work.v[486]-work.L[1302]*work.v[487])*work.d_inv[862];
work.v[863] = 0;
work.d[863] = work.v[863];
if (work.d[863] > 0)
work.d[863] = -settings.kkt_reg;
else
work.d[863] -= settings.kkt_reg;
work.d_inv[863] = 1/work.d[863];
work.L[1284] = (work.KKT[1746])*work.d_inv[863];
work.L[1306] = (work.KKT[1747])*work.d_inv[863];
work.L[1312] = (work.KKT[1748])*work.d_inv[863];
work.v[691] = work.L[1276]*work.d[691];
work.v[692] = work.L[1277]*work.d[692];
work.v[857] = work.L[1278]*work.d[857];
work.v[858] = work.L[1279]*work.d[858];
work.v[859] = work.L[1280]*work.d[859];
work.v[860] = work.L[1281]*work.d[860];
work.v[861] = work.L[1282]*work.d[861];
work.v[862] = work.L[1283]*work.d[862];
work.v[863] = work.L[1284]*work.d[863];
work.v[864] = work.KKT[1749]-work.L[1276]*work.v[691]-work.L[1277]*work.v[692]-work.L[1278]*work.v[857]-work.L[1279]*work.v[858]-work.L[1280]*work.v[859]-work.L[1281]*work.v[860]-work.L[1282]*work.v[861]-work.L[1283]*work.v[862]-work.L[1284]*work.v[863];
work.d[864] = work.v[864];
if (work.d[864] < 0)
work.d[864] = settings.kkt_reg;
else
work.d[864] += settings.kkt_reg;
work.d_inv[864] = 1/work.d[864];
work.L[1291] = (-work.L[1287]*work.v[859]-work.L[1288]*work.v[860]-work.L[1289]*work.v[861]-work.L[1290]*work.v[862])*work.d_inv[864];
work.L[1297] = (-work.L[1295]*work.v[861]-work.L[1296]*work.v[862])*work.d_inv[864];
work.L[1307] = (-work.L[1305]*work.v[862]-work.L[1306]*work.v[863])*work.d_inv[864];
work.L[1313] = (-work.L[1312]*work.v[863])*work.d_inv[864];
work.v[865] = 0;
work.d[865] = work.v[865];
if (work.d[865] > 0)
work.d[865] = -settings.kkt_reg;
else
work.d[865] -= settings.kkt_reg;
work.d_inv[865] = 1/work.d[865];
work.L[1292] = (work.KKT[1750])*work.d_inv[865];
work.L[1314] = (work.KKT[1751])*work.d_inv[865];
work.L[1321] = (work.KKT[1752])*work.d_inv[865];
work.v[590] = work.L[1285]*work.d[590];
work.v[591] = work.L[1286]*work.d[591];
work.v[859] = work.L[1287]*work.d[859];
work.v[860] = work.L[1288]*work.d[860];
work.v[861] = work.L[1289]*work.d[861];
work.v[862] = work.L[1290]*work.d[862];
work.v[864] = work.L[1291]*work.d[864];
work.v[865] = work.L[1292]*work.d[865];
work.v[866] = work.KKT[1753]-work.L[1285]*work.v[590]-work.L[1286]*work.v[591]-work.L[1287]*work.v[859]-work.L[1288]*work.v[860]-work.L[1289]*work.v[861]-work.L[1290]*work.v[862]-work.L[1291]*work.v[864]-work.L[1292]*work.v[865];
work.d[866] = work.v[866];
if (work.d[866] < 0)
work.d[866] = settings.kkt_reg;
else
work.d[866] += settings.kkt_reg;
work.d_inv[866] = 1/work.d[866];
work.L[1298] = (work.KKT[1754]-work.L[1295]*work.v[861]-work.L[1296]*work.v[862]-work.L[1297]*work.v[864])*work.d_inv[866];
work.L[1308] = (-work.L[1305]*work.v[862]-work.L[1307]*work.v[864])*work.d_inv[866];
work.L[1315] = (-work.L[1313]*work.v[864]-work.L[1314]*work.v[865])*work.d_inv[866];
work.L[1322] = (-work.L[1321]*work.v[865])*work.d_inv[866];
work.v[757] = work.L[1293]*work.d[757];
work.v[758] = work.L[1294]*work.d[758];
work.v[861] = work.L[1295]*work.d[861];
work.v[862] = work.L[1296]*work.d[862];
work.v[864] = work.L[1297]*work.d[864];
work.v[866] = work.L[1298]*work.d[866];
work.v[867] = 0-work.L[1293]*work.v[757]-work.L[1294]*work.v[758]-work.L[1295]*work.v[861]-work.L[1296]*work.v[862]-work.L[1297]*work.v[864]-work.L[1298]*work.v[866];
work.d[867] = work.v[867];
if (work.d[867] > 0)
work.d[867] = -settings.kkt_reg;
else
work.d[867] -= settings.kkt_reg;
work.d_inv[867] = 1/work.d[867];
work.L[1309] = (-work.L[1305]*work.v[862]-work.L[1307]*work.v[864]-work.L[1308]*work.v[866])*work.d_inv[867];
work.L[1316] = (-work.L[1313]*work.v[864]-work.L[1315]*work.v[866])*work.d_inv[867];
work.L[1323] = (-work.L[1322]*work.v[866])*work.d_inv[867];
work.L[1329] = (-work.L[1327]*work.v[758])*work.d_inv[867];
work.v[382] = work.L[1299]*work.d[382];
work.v[383] = work.L[1300]*work.d[383];
work.v[486] = work.L[1301]*work.d[486];
work.v[487] = work.L[1302]*work.d[487];
work.v[490] = work.L[1303]*work.d[490];
work.v[491] = work.L[1304]*work.d[491];
work.v[862] = work.L[1305]*work.d[862];
work.v[863] = work.L[1306]*work.d[863];
work.v[864] = work.L[1307]*work.d[864];
work.v[866] = work.L[1308]*work.d[866];
work.v[867] = work.L[1309]*work.d[867];
work.v[868] = 0-work.L[1299]*work.v[382]-work.L[1300]*work.v[383]-work.L[1301]*work.v[486]-work.L[1302]*work.v[487]-work.L[1303]*work.v[490]-work.L[1304]*work.v[491]-work.L[1305]*work.v[862]-work.L[1306]*work.v[863]-work.L[1307]*work.v[864]-work.L[1308]*work.v[866]-work.L[1309]*work.v[867];
work.d[868] = work.v[868];
if (work.d[868] < 0)
work.d[868] = settings.kkt_reg;
else
work.d[868] += settings.kkt_reg;
work.d_inv[868] = 1/work.d[868];
work.L[1317] = (-work.L[1312]*work.v[863]-work.L[1313]*work.v[864]-work.L[1315]*work.v[866]-work.L[1316]*work.v[867])*work.d_inv[868];
work.L[1324] = (-work.L[1322]*work.v[866]-work.L[1323]*work.v[867])*work.d_inv[868];
work.L[1330] = (-work.L[1329]*work.v[867])*work.d_inv[868];
work.L[1339] = (-work.L[1335]*work.v[490]-work.L[1336]*work.v[491])*work.d_inv[868];
work.v[869] = 0;
work.d[869] = work.v[869];
if (work.d[869] > 0)
work.d[869] = -settings.kkt_reg;
else
work.d[869] -= settings.kkt_reg;
work.d_inv[869] = 1/work.d[869];
work.L[1318] = (work.KKT[1755])*work.d_inv[869];
work.L[1340] = (work.KKT[1756])*work.d_inv[869];
work.L[1346] = (work.KKT[1757])*work.d_inv[869];
work.v[695] = work.L[1310]*work.d[695];
work.v[696] = work.L[1311]*work.d[696];
work.v[863] = work.L[1312]*work.d[863];
work.v[864] = work.L[1313]*work.d[864];
work.v[865] = work.L[1314]*work.d[865];
work.v[866] = work.L[1315]*work.d[866];
work.v[867] = work.L[1316]*work.d[867];
work.v[868] = work.L[1317]*work.d[868];
work.v[869] = work.L[1318]*work.d[869];
work.v[870] = work.KKT[1758]-work.L[1310]*work.v[695]-work.L[1311]*work.v[696]-work.L[1312]*work.v[863]-work.L[1313]*work.v[864]-work.L[1314]*work.v[865]-work.L[1315]*work.v[866]-work.L[1316]*work.v[867]-work.L[1317]*work.v[868]-work.L[1318]*work.v[869];
work.d[870] = work.v[870];
if (work.d[870] < 0)
work.d[870] = settings.kkt_reg;
else
work.d[870] += settings.kkt_reg;
work.d_inv[870] = 1/work.d[870];
work.L[1325] = (-work.L[1321]*work.v[865]-work.L[1322]*work.v[866]-work.L[1323]*work.v[867]-work.L[1324]*work.v[868])*work.d_inv[870];
work.L[1331] = (-work.L[1329]*work.v[867]-work.L[1330]*work.v[868])*work.d_inv[870];
work.L[1341] = (-work.L[1339]*work.v[868]-work.L[1340]*work.v[869])*work.d_inv[870];
work.L[1347] = (-work.L[1346]*work.v[869])*work.d_inv[870];
work.v[871] = 0;
work.d[871] = work.v[871];
if (work.d[871] > 0)
work.d[871] = -settings.kkt_reg;
else
work.d[871] -= settings.kkt_reg;
work.d_inv[871] = 1/work.d[871];
work.L[1326] = (work.KKT[1759])*work.d_inv[871];
work.L[1348] = (work.KKT[1760])*work.d_inv[871];
work.L[1355] = (work.KKT[1761])*work.d_inv[871];
work.v[594] = work.L[1319]*work.d[594];
work.v[595] = work.L[1320]*work.d[595];
work.v[865] = work.L[1321]*work.d[865];
work.v[866] = work.L[1322]*work.d[866];
work.v[867] = work.L[1323]*work.d[867];
work.v[868] = work.L[1324]*work.d[868];
work.v[870] = work.L[1325]*work.d[870];
work.v[871] = work.L[1326]*work.d[871];
work.v[872] = work.KKT[1762]-work.L[1319]*work.v[594]-work.L[1320]*work.v[595]-work.L[1321]*work.v[865]-work.L[1322]*work.v[866]-work.L[1323]*work.v[867]-work.L[1324]*work.v[868]-work.L[1325]*work.v[870]-work.L[1326]*work.v[871];
work.d[872] = work.v[872];
if (work.d[872] < 0)
work.d[872] = settings.kkt_reg;
else
work.d[872] += settings.kkt_reg;
work.d_inv[872] = 1/work.d[872];
work.L[1332] = (work.KKT[1763]-work.L[1329]*work.v[867]-work.L[1330]*work.v[868]-work.L[1331]*work.v[870])*work.d_inv[872];
work.L[1342] = (-work.L[1339]*work.v[868]-work.L[1341]*work.v[870])*work.d_inv[872];
work.L[1349] = (-work.L[1347]*work.v[870]-work.L[1348]*work.v[871])*work.d_inv[872];
work.L[1356] = (-work.L[1355]*work.v[871])*work.d_inv[872];
work.v[758] = work.L[1327]*work.d[758];
work.v[759] = work.L[1328]*work.d[759];
work.v[867] = work.L[1329]*work.d[867];
work.v[868] = work.L[1330]*work.d[868];
work.v[870] = work.L[1331]*work.d[870];
work.v[872] = work.L[1332]*work.d[872];
work.v[873] = 0-work.L[1327]*work.v[758]-work.L[1328]*work.v[759]-work.L[1329]*work.v[867]-work.L[1330]*work.v[868]-work.L[1331]*work.v[870]-work.L[1332]*work.v[872];
work.d[873] = work.v[873];
if (work.d[873] > 0)
work.d[873] = -settings.kkt_reg;
else
work.d[873] -= settings.kkt_reg;
work.d_inv[873] = 1/work.d[873];
work.L[1343] = (-work.L[1339]*work.v[868]-work.L[1341]*work.v[870]-work.L[1342]*work.v[872])*work.d_inv[873];
work.L[1350] = (-work.L[1347]*work.v[870]-work.L[1349]*work.v[872])*work.d_inv[873];
work.L[1357] = (-work.L[1356]*work.v[872])*work.d_inv[873];
work.L[1363] = (-work.L[1361]*work.v[759])*work.d_inv[873];
work.v[386] = work.L[1333]*work.d[386];
work.v[387] = work.L[1334]*work.d[387];
work.v[490] = work.L[1335]*work.d[490];
work.v[491] = work.L[1336]*work.d[491];
work.v[494] = work.L[1337]*work.d[494];
work.v[495] = work.L[1338]*work.d[495];
work.v[868] = work.L[1339]*work.d[868];
work.v[869] = work.L[1340]*work.d[869];
work.v[870] = work.L[1341]*work.d[870];
work.v[872] = work.L[1342]*work.d[872];
work.v[873] = work.L[1343]*work.d[873];
work.v[874] = 0-work.L[1333]*work.v[386]-work.L[1334]*work.v[387]-work.L[1335]*work.v[490]-work.L[1336]*work.v[491]-work.L[1337]*work.v[494]-work.L[1338]*work.v[495]-work.L[1339]*work.v[868]-work.L[1340]*work.v[869]-work.L[1341]*work.v[870]-work.L[1342]*work.v[872]-work.L[1343]*work.v[873];
work.d[874] = work.v[874];
if (work.d[874] < 0)
work.d[874] = settings.kkt_reg;
else
work.d[874] += settings.kkt_reg;
work.d_inv[874] = 1/work.d[874];
work.L[1351] = (-work.L[1346]*work.v[869]-work.L[1347]*work.v[870]-work.L[1349]*work.v[872]-work.L[1350]*work.v[873])*work.d_inv[874];
work.L[1358] = (-work.L[1356]*work.v[872]-work.L[1357]*work.v[873])*work.d_inv[874];
work.L[1364] = (-work.L[1363]*work.v[873])*work.d_inv[874];
work.L[1373] = (-work.L[1369]*work.v[494]-work.L[1370]*work.v[495])*work.d_inv[874];
work.v[875] = 0;
work.d[875] = work.v[875];
if (work.d[875] > 0)
work.d[875] = -settings.kkt_reg;
else
work.d[875] -= settings.kkt_reg;
work.d_inv[875] = 1/work.d[875];
work.L[1352] = (work.KKT[1764])*work.d_inv[875];
work.L[1374] = (work.KKT[1765])*work.d_inv[875];
work.L[1380] = (work.KKT[1766])*work.d_inv[875];
work.v[699] = work.L[1344]*work.d[699];
work.v[700] = work.L[1345]*work.d[700];
work.v[869] = work.L[1346]*work.d[869];
work.v[870] = work.L[1347]*work.d[870];
work.v[871] = work.L[1348]*work.d[871];
work.v[872] = work.L[1349]*work.d[872];
work.v[873] = work.L[1350]*work.d[873];
work.v[874] = work.L[1351]*work.d[874];
work.v[875] = work.L[1352]*work.d[875];
work.v[876] = work.KKT[1767]-work.L[1344]*work.v[699]-work.L[1345]*work.v[700]-work.L[1346]*work.v[869]-work.L[1347]*work.v[870]-work.L[1348]*work.v[871]-work.L[1349]*work.v[872]-work.L[1350]*work.v[873]-work.L[1351]*work.v[874]-work.L[1352]*work.v[875];
work.d[876] = work.v[876];
if (work.d[876] < 0)
work.d[876] = settings.kkt_reg;
else
work.d[876] += settings.kkt_reg;
work.d_inv[876] = 1/work.d[876];
work.L[1359] = (-work.L[1355]*work.v[871]-work.L[1356]*work.v[872]-work.L[1357]*work.v[873]-work.L[1358]*work.v[874])*work.d_inv[876];
work.L[1365] = (-work.L[1363]*work.v[873]-work.L[1364]*work.v[874])*work.d_inv[876];
work.L[1375] = (-work.L[1373]*work.v[874]-work.L[1374]*work.v[875])*work.d_inv[876];
work.L[1381] = (-work.L[1380]*work.v[875])*work.d_inv[876];
work.v[877] = 0;
work.d[877] = work.v[877];
if (work.d[877] > 0)
work.d[877] = -settings.kkt_reg;
else
work.d[877] -= settings.kkt_reg;
work.d_inv[877] = 1/work.d[877];
work.L[1360] = (work.KKT[1768])*work.d_inv[877];
work.L[1382] = (work.KKT[1769])*work.d_inv[877];
work.L[1389] = (work.KKT[1770])*work.d_inv[877];
work.v[598] = work.L[1353]*work.d[598];
work.v[599] = work.L[1354]*work.d[599];
work.v[871] = work.L[1355]*work.d[871];
work.v[872] = work.L[1356]*work.d[872];
work.v[873] = work.L[1357]*work.d[873];
work.v[874] = work.L[1358]*work.d[874];
work.v[876] = work.L[1359]*work.d[876];
work.v[877] = work.L[1360]*work.d[877];
work.v[878] = work.KKT[1771]-work.L[1353]*work.v[598]-work.L[1354]*work.v[599]-work.L[1355]*work.v[871]-work.L[1356]*work.v[872]-work.L[1357]*work.v[873]-work.L[1358]*work.v[874]-work.L[1359]*work.v[876]-work.L[1360]*work.v[877];
work.d[878] = work.v[878];
if (work.d[878] < 0)
work.d[878] = settings.kkt_reg;
else
work.d[878] += settings.kkt_reg;
work.d_inv[878] = 1/work.d[878];
work.L[1366] = (work.KKT[1772]-work.L[1363]*work.v[873]-work.L[1364]*work.v[874]-work.L[1365]*work.v[876])*work.d_inv[878];
work.L[1376] = (-work.L[1373]*work.v[874]-work.L[1375]*work.v[876])*work.d_inv[878];
work.L[1383] = (-work.L[1381]*work.v[876]-work.L[1382]*work.v[877])*work.d_inv[878];
work.L[1390] = (-work.L[1389]*work.v[877])*work.d_inv[878];
work.v[759] = work.L[1361]*work.d[759];
work.v[760] = work.L[1362]*work.d[760];
work.v[873] = work.L[1363]*work.d[873];
work.v[874] = work.L[1364]*work.d[874];
work.v[876] = work.L[1365]*work.d[876];
work.v[878] = work.L[1366]*work.d[878];
work.v[879] = 0-work.L[1361]*work.v[759]-work.L[1362]*work.v[760]-work.L[1363]*work.v[873]-work.L[1364]*work.v[874]-work.L[1365]*work.v[876]-work.L[1366]*work.v[878];
work.d[879] = work.v[879];
if (work.d[879] > 0)
work.d[879] = -settings.kkt_reg;
else
work.d[879] -= settings.kkt_reg;
work.d_inv[879] = 1/work.d[879];
work.L[1377] = (-work.L[1373]*work.v[874]-work.L[1375]*work.v[876]-work.L[1376]*work.v[878])*work.d_inv[879];
work.L[1384] = (-work.L[1381]*work.v[876]-work.L[1383]*work.v[878])*work.d_inv[879];
work.L[1391] = (-work.L[1390]*work.v[878])*work.d_inv[879];
work.L[1397] = (-work.L[1395]*work.v[760])*work.d_inv[879];
work.v[390] = work.L[1367]*work.d[390];
work.v[391] = work.L[1368]*work.d[391];
work.v[494] = work.L[1369]*work.d[494];
work.v[495] = work.L[1370]*work.d[495];
work.v[498] = work.L[1371]*work.d[498];
work.v[499] = work.L[1372]*work.d[499];
work.v[874] = work.L[1373]*work.d[874];
work.v[875] = work.L[1374]*work.d[875];
work.v[876] = work.L[1375]*work.d[876];
work.v[878] = work.L[1376]*work.d[878];
work.v[879] = work.L[1377]*work.d[879];
work.v[880] = 0-work.L[1367]*work.v[390]-work.L[1368]*work.v[391]-work.L[1369]*work.v[494]-work.L[1370]*work.v[495]-work.L[1371]*work.v[498]-work.L[1372]*work.v[499]-work.L[1373]*work.v[874]-work.L[1374]*work.v[875]-work.L[1375]*work.v[876]-work.L[1376]*work.v[878]-work.L[1377]*work.v[879];
work.d[880] = work.v[880];
if (work.d[880] < 0)
work.d[880] = settings.kkt_reg;
else
work.d[880] += settings.kkt_reg;
work.d_inv[880] = 1/work.d[880];
work.L[1385] = (-work.L[1380]*work.v[875]-work.L[1381]*work.v[876]-work.L[1383]*work.v[878]-work.L[1384]*work.v[879])*work.d_inv[880];
work.L[1392] = (-work.L[1390]*work.v[878]-work.L[1391]*work.v[879])*work.d_inv[880];
work.L[1398] = (-work.L[1397]*work.v[879])*work.d_inv[880];
work.L[1407] = (-work.L[1403]*work.v[498]-work.L[1404]*work.v[499])*work.d_inv[880];
work.v[881] = 0;
work.d[881] = work.v[881];
if (work.d[881] > 0)
work.d[881] = -settings.kkt_reg;
else
work.d[881] -= settings.kkt_reg;
work.d_inv[881] = 1/work.d[881];
work.L[1386] = (work.KKT[1773])*work.d_inv[881];
work.L[1408] = (work.KKT[1774])*work.d_inv[881];
work.L[1414] = (work.KKT[1775])*work.d_inv[881];
work.v[703] = work.L[1378]*work.d[703];
work.v[704] = work.L[1379]*work.d[704];
work.v[875] = work.L[1380]*work.d[875];
work.v[876] = work.L[1381]*work.d[876];
work.v[877] = work.L[1382]*work.d[877];
work.v[878] = work.L[1383]*work.d[878];
work.v[879] = work.L[1384]*work.d[879];
work.v[880] = work.L[1385]*work.d[880];
work.v[881] = work.L[1386]*work.d[881];
work.v[882] = work.KKT[1776]-work.L[1378]*work.v[703]-work.L[1379]*work.v[704]-work.L[1380]*work.v[875]-work.L[1381]*work.v[876]-work.L[1382]*work.v[877]-work.L[1383]*work.v[878]-work.L[1384]*work.v[879]-work.L[1385]*work.v[880]-work.L[1386]*work.v[881];
work.d[882] = work.v[882];
if (work.d[882] < 0)
work.d[882] = settings.kkt_reg;
else
work.d[882] += settings.kkt_reg;
work.d_inv[882] = 1/work.d[882];
work.L[1393] = (-work.L[1389]*work.v[877]-work.L[1390]*work.v[878]-work.L[1391]*work.v[879]-work.L[1392]*work.v[880])*work.d_inv[882];
work.L[1399] = (-work.L[1397]*work.v[879]-work.L[1398]*work.v[880])*work.d_inv[882];
work.L[1409] = (-work.L[1407]*work.v[880]-work.L[1408]*work.v[881])*work.d_inv[882];
work.L[1415] = (-work.L[1414]*work.v[881])*work.d_inv[882];
work.v[883] = 0;
work.d[883] = work.v[883];
if (work.d[883] > 0)
work.d[883] = -settings.kkt_reg;
else
work.d[883] -= settings.kkt_reg;
work.d_inv[883] = 1/work.d[883];
work.L[1394] = (work.KKT[1777])*work.d_inv[883];
work.L[1416] = (work.KKT[1778])*work.d_inv[883];
work.L[1423] = (work.KKT[1779])*work.d_inv[883];
work.v[602] = work.L[1387]*work.d[602];
work.v[603] = work.L[1388]*work.d[603];
work.v[877] = work.L[1389]*work.d[877];
work.v[878] = work.L[1390]*work.d[878];
work.v[879] = work.L[1391]*work.d[879];
work.v[880] = work.L[1392]*work.d[880];
work.v[882] = work.L[1393]*work.d[882];
work.v[883] = work.L[1394]*work.d[883];
work.v[884] = work.KKT[1780]-work.L[1387]*work.v[602]-work.L[1388]*work.v[603]-work.L[1389]*work.v[877]-work.L[1390]*work.v[878]-work.L[1391]*work.v[879]-work.L[1392]*work.v[880]-work.L[1393]*work.v[882]-work.L[1394]*work.v[883];
work.d[884] = work.v[884];
if (work.d[884] < 0)
work.d[884] = settings.kkt_reg;
else
work.d[884] += settings.kkt_reg;
work.d_inv[884] = 1/work.d[884];
work.L[1400] = (work.KKT[1781]-work.L[1397]*work.v[879]-work.L[1398]*work.v[880]-work.L[1399]*work.v[882])*work.d_inv[884];
work.L[1410] = (-work.L[1407]*work.v[880]-work.L[1409]*work.v[882])*work.d_inv[884];
work.L[1417] = (-work.L[1415]*work.v[882]-work.L[1416]*work.v[883])*work.d_inv[884];
work.L[1424] = (-work.L[1423]*work.v[883])*work.d_inv[884];
work.v[760] = work.L[1395]*work.d[760];
work.v[761] = work.L[1396]*work.d[761];
work.v[879] = work.L[1397]*work.d[879];
work.v[880] = work.L[1398]*work.d[880];
work.v[882] = work.L[1399]*work.d[882];
work.v[884] = work.L[1400]*work.d[884];
work.v[885] = 0-work.L[1395]*work.v[760]-work.L[1396]*work.v[761]-work.L[1397]*work.v[879]-work.L[1398]*work.v[880]-work.L[1399]*work.v[882]-work.L[1400]*work.v[884];
work.d[885] = work.v[885];
if (work.d[885] > 0)
work.d[885] = -settings.kkt_reg;
else
work.d[885] -= settings.kkt_reg;
work.d_inv[885] = 1/work.d[885];
work.L[1411] = (-work.L[1407]*work.v[880]-work.L[1409]*work.v[882]-work.L[1410]*work.v[884])*work.d_inv[885];
work.L[1418] = (-work.L[1415]*work.v[882]-work.L[1417]*work.v[884])*work.d_inv[885];
work.L[1425] = (-work.L[1424]*work.v[884])*work.d_inv[885];
work.L[1431] = (-work.L[1429]*work.v[761])*work.d_inv[885];
work.v[394] = work.L[1401]*work.d[394];
work.v[395] = work.L[1402]*work.d[395];
work.v[498] = work.L[1403]*work.d[498];
work.v[499] = work.L[1404]*work.d[499];
work.v[502] = work.L[1405]*work.d[502];
work.v[503] = work.L[1406]*work.d[503];
work.v[880] = work.L[1407]*work.d[880];
work.v[881] = work.L[1408]*work.d[881];
work.v[882] = work.L[1409]*work.d[882];
work.v[884] = work.L[1410]*work.d[884];
work.v[885] = work.L[1411]*work.d[885];
work.v[886] = 0-work.L[1401]*work.v[394]-work.L[1402]*work.v[395]-work.L[1403]*work.v[498]-work.L[1404]*work.v[499]-work.L[1405]*work.v[502]-work.L[1406]*work.v[503]-work.L[1407]*work.v[880]-work.L[1408]*work.v[881]-work.L[1409]*work.v[882]-work.L[1410]*work.v[884]-work.L[1411]*work.v[885];
work.d[886] = work.v[886];
if (work.d[886] < 0)
work.d[886] = settings.kkt_reg;
else
work.d[886] += settings.kkt_reg;
work.d_inv[886] = 1/work.d[886];
work.L[1419] = (-work.L[1414]*work.v[881]-work.L[1415]*work.v[882]-work.L[1417]*work.v[884]-work.L[1418]*work.v[885])*work.d_inv[886];
work.L[1426] = (-work.L[1424]*work.v[884]-work.L[1425]*work.v[885])*work.d_inv[886];
work.L[1432] = (-work.L[1431]*work.v[885])*work.d_inv[886];
work.L[1441] = (-work.L[1437]*work.v[502]-work.L[1438]*work.v[503])*work.d_inv[886];
work.v[887] = 0;
work.d[887] = work.v[887];
if (work.d[887] > 0)
work.d[887] = -settings.kkt_reg;
else
work.d[887] -= settings.kkt_reg;
work.d_inv[887] = 1/work.d[887];
work.L[1420] = (work.KKT[1782])*work.d_inv[887];
work.L[1442] = (work.KKT[1783])*work.d_inv[887];
work.L[1448] = (work.KKT[1784])*work.d_inv[887];
work.v[707] = work.L[1412]*work.d[707];
work.v[708] = work.L[1413]*work.d[708];
work.v[881] = work.L[1414]*work.d[881];
work.v[882] = work.L[1415]*work.d[882];
work.v[883] = work.L[1416]*work.d[883];
work.v[884] = work.L[1417]*work.d[884];
work.v[885] = work.L[1418]*work.d[885];
work.v[886] = work.L[1419]*work.d[886];
work.v[887] = work.L[1420]*work.d[887];
work.v[888] = work.KKT[1785]-work.L[1412]*work.v[707]-work.L[1413]*work.v[708]-work.L[1414]*work.v[881]-work.L[1415]*work.v[882]-work.L[1416]*work.v[883]-work.L[1417]*work.v[884]-work.L[1418]*work.v[885]-work.L[1419]*work.v[886]-work.L[1420]*work.v[887];
work.d[888] = work.v[888];
if (work.d[888] < 0)
work.d[888] = settings.kkt_reg;
else
work.d[888] += settings.kkt_reg;
work.d_inv[888] = 1/work.d[888];
work.L[1427] = (-work.L[1423]*work.v[883]-work.L[1424]*work.v[884]-work.L[1425]*work.v[885]-work.L[1426]*work.v[886])*work.d_inv[888];
work.L[1433] = (-work.L[1431]*work.v[885]-work.L[1432]*work.v[886])*work.d_inv[888];
work.L[1443] = (-work.L[1441]*work.v[886]-work.L[1442]*work.v[887])*work.d_inv[888];
work.L[1449] = (-work.L[1448]*work.v[887])*work.d_inv[888];
work.v[889] = 0;
work.d[889] = work.v[889];
if (work.d[889] > 0)
work.d[889] = -settings.kkt_reg;
else
work.d[889] -= settings.kkt_reg;
work.d_inv[889] = 1/work.d[889];
work.L[1428] = (work.KKT[1786])*work.d_inv[889];
work.L[1450] = (work.KKT[1787])*work.d_inv[889];
work.L[1457] = (work.KKT[1788])*work.d_inv[889];
work.v[606] = work.L[1421]*work.d[606];
work.v[607] = work.L[1422]*work.d[607];
work.v[883] = work.L[1423]*work.d[883];
work.v[884] = work.L[1424]*work.d[884];
work.v[885] = work.L[1425]*work.d[885];
work.v[886] = work.L[1426]*work.d[886];
work.v[888] = work.L[1427]*work.d[888];
work.v[889] = work.L[1428]*work.d[889];
work.v[890] = work.KKT[1789]-work.L[1421]*work.v[606]-work.L[1422]*work.v[607]-work.L[1423]*work.v[883]-work.L[1424]*work.v[884]-work.L[1425]*work.v[885]-work.L[1426]*work.v[886]-work.L[1427]*work.v[888]-work.L[1428]*work.v[889];
work.d[890] = work.v[890];
if (work.d[890] < 0)
work.d[890] = settings.kkt_reg;
else
work.d[890] += settings.kkt_reg;
work.d_inv[890] = 1/work.d[890];
work.L[1434] = (work.KKT[1790]-work.L[1431]*work.v[885]-work.L[1432]*work.v[886]-work.L[1433]*work.v[888])*work.d_inv[890];
work.L[1444] = (-work.L[1441]*work.v[886]-work.L[1443]*work.v[888])*work.d_inv[890];
work.L[1451] = (-work.L[1449]*work.v[888]-work.L[1450]*work.v[889])*work.d_inv[890];
work.L[1458] = (-work.L[1457]*work.v[889])*work.d_inv[890];
work.v[761] = work.L[1429]*work.d[761];
work.v[762] = work.L[1430]*work.d[762];
work.v[885] = work.L[1431]*work.d[885];
work.v[886] = work.L[1432]*work.d[886];
work.v[888] = work.L[1433]*work.d[888];
work.v[890] = work.L[1434]*work.d[890];
work.v[891] = 0-work.L[1429]*work.v[761]-work.L[1430]*work.v[762]-work.L[1431]*work.v[885]-work.L[1432]*work.v[886]-work.L[1433]*work.v[888]-work.L[1434]*work.v[890];
work.d[891] = work.v[891];
if (work.d[891] > 0)
work.d[891] = -settings.kkt_reg;
else
work.d[891] -= settings.kkt_reg;
work.d_inv[891] = 1/work.d[891];
work.L[1445] = (-work.L[1441]*work.v[886]-work.L[1443]*work.v[888]-work.L[1444]*work.v[890])*work.d_inv[891];
work.L[1452] = (-work.L[1449]*work.v[888]-work.L[1451]*work.v[890])*work.d_inv[891];
work.L[1459] = (-work.L[1458]*work.v[890])*work.d_inv[891];
work.L[1465] = (-work.L[1463]*work.v[762])*work.d_inv[891];
work.v[398] = work.L[1435]*work.d[398];
work.v[399] = work.L[1436]*work.d[399];
work.v[502] = work.L[1437]*work.d[502];
work.v[503] = work.L[1438]*work.d[503];
work.v[506] = work.L[1439]*work.d[506];
work.v[507] = work.L[1440]*work.d[507];
work.v[886] = work.L[1441]*work.d[886];
work.v[887] = work.L[1442]*work.d[887];
work.v[888] = work.L[1443]*work.d[888];
work.v[890] = work.L[1444]*work.d[890];
work.v[891] = work.L[1445]*work.d[891];
work.v[892] = 0-work.L[1435]*work.v[398]-work.L[1436]*work.v[399]-work.L[1437]*work.v[502]-work.L[1438]*work.v[503]-work.L[1439]*work.v[506]-work.L[1440]*work.v[507]-work.L[1441]*work.v[886]-work.L[1442]*work.v[887]-work.L[1443]*work.v[888]-work.L[1444]*work.v[890]-work.L[1445]*work.v[891];
work.d[892] = work.v[892];
if (work.d[892] < 0)
work.d[892] = settings.kkt_reg;
else
work.d[892] += settings.kkt_reg;
work.d_inv[892] = 1/work.d[892];
work.L[1453] = (-work.L[1448]*work.v[887]-work.L[1449]*work.v[888]-work.L[1451]*work.v[890]-work.L[1452]*work.v[891])*work.d_inv[892];
work.L[1460] = (-work.L[1458]*work.v[890]-work.L[1459]*work.v[891])*work.d_inv[892];
work.L[1466] = (-work.L[1465]*work.v[891])*work.d_inv[892];
work.L[1475] = (-work.L[1471]*work.v[506]-work.L[1472]*work.v[507])*work.d_inv[892];
work.v[893] = 0;
work.d[893] = work.v[893];
if (work.d[893] > 0)
work.d[893] = -settings.kkt_reg;
else
work.d[893] -= settings.kkt_reg;
work.d_inv[893] = 1/work.d[893];
work.L[1454] = (work.KKT[1791])*work.d_inv[893];
work.L[1476] = (work.KKT[1792])*work.d_inv[893];
work.L[1482] = (work.KKT[1793])*work.d_inv[893];
work.v[711] = work.L[1446]*work.d[711];
work.v[712] = work.L[1447]*work.d[712];
work.v[887] = work.L[1448]*work.d[887];
work.v[888] = work.L[1449]*work.d[888];
work.v[889] = work.L[1450]*work.d[889];
work.v[890] = work.L[1451]*work.d[890];
work.v[891] = work.L[1452]*work.d[891];
work.v[892] = work.L[1453]*work.d[892];
work.v[893] = work.L[1454]*work.d[893];
work.v[894] = work.KKT[1794]-work.L[1446]*work.v[711]-work.L[1447]*work.v[712]-work.L[1448]*work.v[887]-work.L[1449]*work.v[888]-work.L[1450]*work.v[889]-work.L[1451]*work.v[890]-work.L[1452]*work.v[891]-work.L[1453]*work.v[892]-work.L[1454]*work.v[893];
work.d[894] = work.v[894];
if (work.d[894] < 0)
work.d[894] = settings.kkt_reg;
else
work.d[894] += settings.kkt_reg;
work.d_inv[894] = 1/work.d[894];
work.L[1461] = (-work.L[1457]*work.v[889]-work.L[1458]*work.v[890]-work.L[1459]*work.v[891]-work.L[1460]*work.v[892])*work.d_inv[894];
work.L[1467] = (-work.L[1465]*work.v[891]-work.L[1466]*work.v[892])*work.d_inv[894];
work.L[1477] = (-work.L[1475]*work.v[892]-work.L[1476]*work.v[893])*work.d_inv[894];
work.L[1483] = (-work.L[1482]*work.v[893])*work.d_inv[894];
work.v[895] = 0;
work.d[895] = work.v[895];
if (work.d[895] > 0)
work.d[895] = -settings.kkt_reg;
else
work.d[895] -= settings.kkt_reg;
work.d_inv[895] = 1/work.d[895];
work.L[1462] = (work.KKT[1795])*work.d_inv[895];
work.L[1484] = (work.KKT[1796])*work.d_inv[895];
work.L[1538] = (work.KKT[1797])*work.d_inv[895];
work.v[610] = work.L[1455]*work.d[610];
work.v[611] = work.L[1456]*work.d[611];
work.v[889] = work.L[1457]*work.d[889];
work.v[890] = work.L[1458]*work.d[890];
work.v[891] = work.L[1459]*work.d[891];
work.v[892] = work.L[1460]*work.d[892];
work.v[894] = work.L[1461]*work.d[894];
work.v[895] = work.L[1462]*work.d[895];
work.v[896] = work.KKT[1798]-work.L[1455]*work.v[610]-work.L[1456]*work.v[611]-work.L[1457]*work.v[889]-work.L[1458]*work.v[890]-work.L[1459]*work.v[891]-work.L[1460]*work.v[892]-work.L[1461]*work.v[894]-work.L[1462]*work.v[895];
work.d[896] = work.v[896];
if (work.d[896] < 0)
work.d[896] = settings.kkt_reg;
else
work.d[896] += settings.kkt_reg;
work.d_inv[896] = 1/work.d[896];
work.L[1468] = (work.KKT[1799]-work.L[1465]*work.v[891]-work.L[1466]*work.v[892]-work.L[1467]*work.v[894])*work.d_inv[896];
work.L[1478] = (-work.L[1475]*work.v[892]-work.L[1477]*work.v[894])*work.d_inv[896];
work.L[1485] = (-work.L[1483]*work.v[894]-work.L[1484]*work.v[895])*work.d_inv[896];
work.L[1539] = (-work.L[1538]*work.v[895])*work.d_inv[896];
work.v[762] = work.L[1463]*work.d[762];
work.v[763] = work.L[1464]*work.d[763];
work.v[891] = work.L[1465]*work.d[891];
work.v[892] = work.L[1466]*work.d[892];
work.v[894] = work.L[1467]*work.d[894];
work.v[896] = work.L[1468]*work.d[896];
work.v[897] = 0-work.L[1463]*work.v[762]-work.L[1464]*work.v[763]-work.L[1465]*work.v[891]-work.L[1466]*work.v[892]-work.L[1467]*work.v[894]-work.L[1468]*work.v[896];
work.d[897] = work.v[897];
if (work.d[897] > 0)
work.d[897] = -settings.kkt_reg;
else
work.d[897] -= settings.kkt_reg;
work.d_inv[897] = 1/work.d[897];
work.L[1479] = (-work.L[1475]*work.v[892]-work.L[1477]*work.v[894]-work.L[1478]*work.v[896])*work.d_inv[897];
work.L[1486] = (-work.L[1483]*work.v[894]-work.L[1485]*work.v[896])*work.d_inv[897];
work.L[1529] = (-work.L[1526]*work.v[763])*work.d_inv[897];
work.L[1540] = (-work.L[1539]*work.v[896])*work.d_inv[897];
work.v[402] = work.L[1469]*work.d[402];
work.v[403] = work.L[1470]*work.d[403];
work.v[506] = work.L[1471]*work.d[506];
work.v[507] = work.L[1472]*work.d[507];
work.v[510] = work.L[1473]*work.d[510];
work.v[511] = work.L[1474]*work.d[511];
work.v[892] = work.L[1475]*work.d[892];
work.v[893] = work.L[1476]*work.d[893];
work.v[894] = work.L[1477]*work.d[894];
work.v[896] = work.L[1478]*work.d[896];
work.v[897] = work.L[1479]*work.d[897];
work.v[898] = 0-work.L[1469]*work.v[402]-work.L[1470]*work.v[403]-work.L[1471]*work.v[506]-work.L[1472]*work.v[507]-work.L[1473]*work.v[510]-work.L[1474]*work.v[511]-work.L[1475]*work.v[892]-work.L[1476]*work.v[893]-work.L[1477]*work.v[894]-work.L[1478]*work.v[896]-work.L[1479]*work.v[897];
work.d[898] = work.v[898];
if (work.d[898] < 0)
work.d[898] = settings.kkt_reg;
else
work.d[898] += settings.kkt_reg;
work.d_inv[898] = 1/work.d[898];
work.L[1487] = (-work.L[1482]*work.v[893]-work.L[1483]*work.v[894]-work.L[1485]*work.v[896]-work.L[1486]*work.v[897])*work.d_inv[898];
work.L[1495] = (-work.L[1491]*work.v[510]-work.L[1492]*work.v[511])*work.d_inv[898];
work.L[1530] = (-work.L[1529]*work.v[897])*work.d_inv[898];
work.L[1541] = (-work.L[1539]*work.v[896]-work.L[1540]*work.v[897])*work.d_inv[898];
work.v[899] = 0;
work.d[899] = work.v[899];
if (work.d[899] > 0)
work.d[899] = -settings.kkt_reg;
else
work.d[899] -= settings.kkt_reg;
work.d_inv[899] = 1/work.d[899];
work.L[1488] = (work.KKT[1800])*work.d_inv[899];
work.L[1496] = (work.KKT[1801])*work.d_inv[899];
work.L[1550] = (work.KKT[1802])*work.d_inv[899];
work.v[715] = work.L[1480]*work.d[715];
work.v[716] = work.L[1481]*work.d[716];
work.v[893] = work.L[1482]*work.d[893];
work.v[894] = work.L[1483]*work.d[894];
work.v[895] = work.L[1484]*work.d[895];
work.v[896] = work.L[1485]*work.d[896];
work.v[897] = work.L[1486]*work.d[897];
work.v[898] = work.L[1487]*work.d[898];
work.v[899] = work.L[1488]*work.d[899];
work.v[900] = work.KKT[1803]-work.L[1480]*work.v[715]-work.L[1481]*work.v[716]-work.L[1482]*work.v[893]-work.L[1483]*work.v[894]-work.L[1484]*work.v[895]-work.L[1485]*work.v[896]-work.L[1486]*work.v[897]-work.L[1487]*work.v[898]-work.L[1488]*work.v[899];
work.d[900] = work.v[900];
if (work.d[900] < 0)
work.d[900] = settings.kkt_reg;
else
work.d[900] += settings.kkt_reg;
work.d_inv[900] = 1/work.d[900];
work.L[1497] = (-work.L[1495]*work.v[898]-work.L[1496]*work.v[899])*work.d_inv[900];
work.L[1531] = (-work.L[1529]*work.v[897]-work.L[1530]*work.v[898])*work.d_inv[900];
work.L[1542] = (-work.L[1538]*work.v[895]-work.L[1539]*work.v[896]-work.L[1540]*work.v[897]-work.L[1541]*work.v[898])*work.d_inv[900];
work.L[1551] = (-work.L[1550]*work.v[899])*work.d_inv[900];
work.v[406] = work.L[1489]*work.d[406];
work.v[407] = work.L[1490]*work.d[407];
work.v[510] = work.L[1491]*work.d[510];
work.v[511] = work.L[1492]*work.d[511];
work.v[514] = work.L[1493]*work.d[514];
work.v[515] = work.L[1494]*work.d[515];
work.v[898] = work.L[1495]*work.d[898];
work.v[899] = work.L[1496]*work.d[899];
work.v[900] = work.L[1497]*work.d[900];
work.v[901] = 0-work.L[1489]*work.v[406]-work.L[1490]*work.v[407]-work.L[1491]*work.v[510]-work.L[1492]*work.v[511]-work.L[1493]*work.v[514]-work.L[1494]*work.v[515]-work.L[1495]*work.v[898]-work.L[1496]*work.v[899]-work.L[1497]*work.v[900];
work.d[901] = work.v[901];
if (work.d[901] < 0)
work.d[901] = settings.kkt_reg;
else
work.d[901] += settings.kkt_reg;
work.d_inv[901] = 1/work.d[901];
work.L[1523] = (-work.L[1516]*work.v[514]-work.L[1517]*work.v[515])*work.d_inv[901];
work.L[1532] = (-work.L[1530]*work.v[898]-work.L[1531]*work.v[900])*work.d_inv[901];
work.L[1543] = (-work.L[1541]*work.v[898]-work.L[1542]*work.v[900])*work.d_inv[901];
work.L[1552] = (-work.L[1550]*work.v[899]-work.L[1551]*work.v[900])*work.d_inv[901];
work.v[622] = work.L[1498]*work.d[622];
work.v[623] = work.L[1499]*work.d[623];
work.v[738] = work.L[1500]*work.d[738];
work.v[739] = work.L[1501]*work.d[739];
work.v[765] = work.L[1502]*work.d[765];
work.v[773] = work.L[1503]*work.d[773];
work.v[775] = work.L[1504]*work.d[775];
work.v[776] = work.L[1505]*work.d[776];
work.v[902] = work.KKT[1804]-work.L[1498]*work.v[622]-work.L[1499]*work.v[623]-work.L[1500]*work.v[738]-work.L[1501]*work.v[739]-work.L[1502]*work.v[765]-work.L[1503]*work.v[773]-work.L[1504]*work.v[775]-work.L[1505]*work.v[776];
work.d[902] = work.v[902];
if (work.d[902] < 0)
work.d[902] = settings.kkt_reg;
else
work.d[902] += settings.kkt_reg;
work.d_inv[902] = 1/work.d[902];
work.L[1513] = (-work.L[1510]*work.v[773]-work.L[1512]*work.v[775])*work.d_inv[902];
work.L[1524] = (-work.L[1521]*work.v[773])*work.d_inv[902];
work.L[1533] = (-work.L[1528]*work.v[776])*work.d_inv[902];
work.L[1562] = (-work.L[1560]*work.v[775]-work.L[1561]*work.v[776])*work.d_inv[902];
work.v[723] = work.L[1506]*work.d[723];
work.v[724] = work.L[1507]*work.d[724];
work.v[771] = work.L[1508]*work.d[771];
work.v[772] = work.L[1509]*work.d[772];
work.v[773] = work.L[1510]*work.d[773];
work.v[774] = work.L[1511]*work.d[774];
work.v[775] = work.L[1512]*work.d[775];
work.v[902] = work.L[1513]*work.d[902];
work.v[903] = work.KKT[1805]-work.L[1506]*work.v[723]-work.L[1507]*work.v[724]-work.L[1508]*work.v[771]-work.L[1509]*work.v[772]-work.L[1510]*work.v[773]-work.L[1511]*work.v[774]-work.L[1512]*work.v[775]-work.L[1513]*work.v[902];
work.d[903] = work.v[903];
if (work.d[903] < 0)
work.d[903] = settings.kkt_reg;
else
work.d[903] += settings.kkt_reg;
work.d_inv[903] = 1/work.d[903];
work.L[1525] = (-work.L[1520]*work.v[772]-work.L[1521]*work.v[773]-work.L[1522]*work.v[774]-work.L[1524]*work.v[902])*work.d_inv[903];
work.L[1534] = (-work.L[1533]*work.v[902])*work.d_inv[903];
work.L[1553] = (-work.L[1549]*work.v[774])*work.d_inv[903];
work.L[1563] = (-work.L[1560]*work.v[775]-work.L[1562]*work.v[902])*work.d_inv[903];
work.v[410] = work.L[1514]*work.d[410];
work.v[411] = work.L[1515]*work.d[411];
work.v[514] = work.L[1516]*work.d[514];
work.v[515] = work.L[1517]*work.d[515];
work.v[518] = work.L[1518]*work.d[518];
work.v[519] = work.L[1519]*work.d[519];
work.v[772] = work.L[1520]*work.d[772];
work.v[773] = work.L[1521]*work.d[773];
work.v[774] = work.L[1522]*work.d[774];
work.v[901] = work.L[1523]*work.d[901];
work.v[902] = work.L[1524]*work.d[902];
work.v[903] = work.L[1525]*work.d[903];
work.v[904] = 0-work.L[1514]*work.v[410]-work.L[1515]*work.v[411]-work.L[1516]*work.v[514]-work.L[1517]*work.v[515]-work.L[1518]*work.v[518]-work.L[1519]*work.v[519]-work.L[1520]*work.v[772]-work.L[1521]*work.v[773]-work.L[1522]*work.v[774]-work.L[1523]*work.v[901]-work.L[1524]*work.v[902]-work.L[1525]*work.v[903];
work.d[904] = work.v[904];
if (work.d[904] < 0)
work.d[904] = settings.kkt_reg;
else
work.d[904] += settings.kkt_reg;
work.d_inv[904] = 1/work.d[904];
work.L[1535] = (-work.L[1532]*work.v[901]-work.L[1533]*work.v[902]-work.L[1534]*work.v[903])*work.d_inv[904];
work.L[1544] = (-work.L[1543]*work.v[901])*work.d_inv[904];
work.L[1554] = (-work.L[1549]*work.v[774]-work.L[1552]*work.v[901]-work.L[1553]*work.v[903])*work.d_inv[904];
work.L[1564] = (-work.L[1562]*work.v[902]-work.L[1563]*work.v[903])*work.d_inv[904];
work.v[763] = work.L[1526]*work.d[763];
work.v[764] = work.L[1527]*work.d[764];
work.v[776] = work.L[1528]*work.d[776];
work.v[897] = work.L[1529]*work.d[897];
work.v[898] = work.L[1530]*work.d[898];
work.v[900] = work.L[1531]*work.d[900];
work.v[901] = work.L[1532]*work.d[901];
work.v[902] = work.L[1533]*work.d[902];
work.v[903] = work.L[1534]*work.d[903];
work.v[904] = work.L[1535]*work.d[904];
work.v[905] = 0-work.L[1526]*work.v[763]-work.L[1527]*work.v[764]-work.L[1528]*work.v[776]-work.L[1529]*work.v[897]-work.L[1530]*work.v[898]-work.L[1531]*work.v[900]-work.L[1532]*work.v[901]-work.L[1533]*work.v[902]-work.L[1534]*work.v[903]-work.L[1535]*work.v[904];
work.d[905] = work.v[905];
if (work.d[905] > 0)
work.d[905] = -settings.kkt_reg;
else
work.d[905] -= settings.kkt_reg;
work.d_inv[905] = 1/work.d[905];
work.L[1545] = (work.KKT[1806]-work.L[1540]*work.v[897]-work.L[1541]*work.v[898]-work.L[1542]*work.v[900]-work.L[1543]*work.v[901]-work.L[1544]*work.v[904])*work.d_inv[905];
work.L[1555] = (-work.L[1551]*work.v[900]-work.L[1552]*work.v[901]-work.L[1553]*work.v[903]-work.L[1554]*work.v[904])*work.d_inv[905];
work.L[1565] = (-work.L[1561]*work.v[776]-work.L[1562]*work.v[902]-work.L[1563]*work.v[903]-work.L[1564]*work.v[904])*work.d_inv[905];
work.v[906] = 0;
work.d[906] = work.v[906];
if (work.d[906] > 0)
work.d[906] = -settings.kkt_reg;
else
work.d[906] -= settings.kkt_reg;
work.d_inv[906] = 1/work.d[906];
work.L[1546] = (work.KKT[1807])*work.d_inv[906];
work.L[1556] = (work.KKT[1808])*work.d_inv[906];
work.L[1566] = (work.KKT[1809])*work.d_inv[906];
work.v[614] = work.L[1536]*work.d[614];
work.v[615] = work.L[1537]*work.d[615];
work.v[895] = work.L[1538]*work.d[895];
work.v[896] = work.L[1539]*work.d[896];
work.v[897] = work.L[1540]*work.d[897];
work.v[898] = work.L[1541]*work.d[898];
work.v[900] = work.L[1542]*work.d[900];
work.v[901] = work.L[1543]*work.d[901];
work.v[904] = work.L[1544]*work.d[904];
work.v[905] = work.L[1545]*work.d[905];
work.v[906] = work.L[1546]*work.d[906];
work.v[907] = work.KKT[1810]-work.L[1536]*work.v[614]-work.L[1537]*work.v[615]-work.L[1538]*work.v[895]-work.L[1539]*work.v[896]-work.L[1540]*work.v[897]-work.L[1541]*work.v[898]-work.L[1542]*work.v[900]-work.L[1543]*work.v[901]-work.L[1544]*work.v[904]-work.L[1545]*work.v[905]-work.L[1546]*work.v[906];
work.d[907] = work.v[907];
if (work.d[907] < 0)
work.d[907] = settings.kkt_reg;
else
work.d[907] += settings.kkt_reg;
work.d_inv[907] = 1/work.d[907];
work.L[1557] = (-work.L[1551]*work.v[900]-work.L[1552]*work.v[901]-work.L[1554]*work.v[904]-work.L[1555]*work.v[905]-work.L[1556]*work.v[906])*work.d_inv[907];
work.L[1567] = (-work.L[1564]*work.v[904]-work.L[1565]*work.v[905]-work.L[1566]*work.v[906])*work.d_inv[907];
work.v[719] = work.L[1547]*work.d[719];
work.v[720] = work.L[1548]*work.d[720];
work.v[774] = work.L[1549]*work.d[774];
work.v[899] = work.L[1550]*work.d[899];
work.v[900] = work.L[1551]*work.d[900];
work.v[901] = work.L[1552]*work.d[901];
work.v[903] = work.L[1553]*work.d[903];
work.v[904] = work.L[1554]*work.d[904];
work.v[905] = work.L[1555]*work.d[905];
work.v[906] = work.L[1556]*work.d[906];
work.v[907] = work.L[1557]*work.d[907];
work.v[908] = work.KKT[1811]-work.L[1547]*work.v[719]-work.L[1548]*work.v[720]-work.L[1549]*work.v[774]-work.L[1550]*work.v[899]-work.L[1551]*work.v[900]-work.L[1552]*work.v[901]-work.L[1553]*work.v[903]-work.L[1554]*work.v[904]-work.L[1555]*work.v[905]-work.L[1556]*work.v[906]-work.L[1557]*work.v[907];
work.d[908] = work.v[908];
if (work.d[908] < 0)
work.d[908] = settings.kkt_reg;
else
work.d[908] += settings.kkt_reg;
work.d_inv[908] = 1/work.d[908];
work.L[1568] = (-work.L[1563]*work.v[903]-work.L[1564]*work.v[904]-work.L[1565]*work.v[905]-work.L[1566]*work.v[906]-work.L[1567]*work.v[907])*work.d_inv[908];
work.v[618] = work.L[1558]*work.d[618];
work.v[619] = work.L[1559]*work.d[619];
work.v[775] = work.L[1560]*work.d[775];
work.v[776] = work.L[1561]*work.d[776];
work.v[902] = work.L[1562]*work.d[902];
work.v[903] = work.L[1563]*work.d[903];
work.v[904] = work.L[1564]*work.d[904];
work.v[905] = work.L[1565]*work.d[905];
work.v[906] = work.L[1566]*work.d[906];
work.v[907] = work.L[1567]*work.d[907];
work.v[908] = work.L[1568]*work.d[908];
work.v[909] = work.KKT[1812]-work.L[1558]*work.v[618]-work.L[1559]*work.v[619]-work.L[1560]*work.v[775]-work.L[1561]*work.v[776]-work.L[1562]*work.v[902]-work.L[1563]*work.v[903]-work.L[1564]*work.v[904]-work.L[1565]*work.v[905]-work.L[1566]*work.v[906]-work.L[1567]*work.v[907]-work.L[1568]*work.v[908];
work.d[909] = work.v[909];
if (work.d[909] < 0)
work.d[909] = settings.kkt_reg;
else
work.d[909] += settings.kkt_reg;
work.d_inv[909] = 1/work.d[909];
#ifndef ZERO_LIBRARY_MODE
if (settings.debug) {
printf("Squared Frobenius for factorization is %.8g.\n", check_factorization());
}
#endif
}
double check_factorization(void) {
/* Returns the squared Frobenius norm of A - L*D*L'. */
double temp, residual;
/* Only check the lower triangle. */
residual = 0;
temp = work.KKT[626]-1*work.d[314]*1-work.L[0]*work.d[312]*work.L[0];
residual += temp*temp;
temp = work.KKT[1526]-1*work.d[741]*1-work.L[750]*work.d[526]*work.L[750]-work.L[751]*work.d[527]*work.L[751]-work.L[749]*work.d[313]*work.L[749]-work.L[752]*work.d[737]*work.L[752];
residual += temp*temp;
temp = work.KKT[1620]-1*work.d[778]*1-work.L[790]*work.d[631]*work.L[790]-work.L[791]*work.d[632]*work.L[791]-work.L[792]*work.d[735]*work.L[792]-work.L[795]*work.d[767]*work.L[795]-work.L[794]*work.d[766]*work.L[794]-work.L[793]*work.d[736]*work.L[793]-work.L[796]*work.d[768]*work.L[796]-work.L[798]*work.d[777]*work.L[798]-work.L[797]*work.d[769]*work.L[797];
residual += temp*temp;
temp = work.KKT[1528]-1*work.d[742]*1-work.L[753]*work.d[737]*work.L[753]-work.L[754]*work.d[741]*work.L[754];
residual += temp*temp;
temp = work.KKT[1618]-1*work.d[777]*1-work.L[786]*work.d[530]*work.L[786]-work.L[787]*work.d[531]*work.L[787]-work.L[788]*work.d[766]*work.L[788]-work.L[789]*work.d[769]*work.L[789];
residual += temp*temp;
temp = work.KKT[1621]-1*work.d[779]*1-work.L[799]*work.d[635]*work.L[799]-work.L[800]*work.d[636]*work.L[800]-work.L[801]*work.d[767]*work.L[801]-work.L[803]*work.d[770]*work.L[803]-work.L[802]*work.d[768]*work.L[802]-work.L[804]*work.d[778]*work.L[804];
residual += temp*temp;
temp = work.KKT[1530]-1*work.d[743]*1;
residual += temp*temp;
temp = work.KKT[1627]-1*work.d[782]*1-work.L[808]*work.d[534]*work.L[808]-work.L[809]*work.d[535]*work.L[809]-work.L[810]*work.d[780]*work.L[810]-work.L[811]*work.d[781]*work.L[811];
residual += temp*temp;
temp = work.KKT[1632]-1*work.d[786]*1-work.L[833]*work.d[639]*work.L[833]-work.L[834]*work.d[640]*work.L[834]-work.L[835]*work.d[770]*work.L[835]-work.L[842]*work.d[785]*work.L[842]-work.L[838]*work.d[781]*work.L[838]-work.L[841]*work.d[784]*work.L[841]-work.L[836]*work.d[779]*work.L[836]-work.L[837]*work.d[780]*work.L[837]-work.L[840]*work.d[783]*work.L[840]-work.L[839]*work.d[782]*work.L[839];
residual += temp*temp;
temp = work.KKT[1533]-1*work.d[744]*1;
residual += temp*temp;
temp = work.KKT[1636]-1*work.d[788]*1-work.L[843]*work.d[538]*work.L[843]-work.L[844]*work.d[539]*work.L[844]-work.L[845]*work.d[781]*work.L[845]-work.L[850]*work.d[787]*work.L[850]-work.L[846]*work.d[782]*work.L[846]-work.L[849]*work.d[786]*work.L[849]-work.L[847]*work.d[783]*work.L[847]-work.L[848]*work.d[784]*work.L[848];
residual += temp*temp;
temp = work.KKT[1641]-1*work.d[792]*1-work.L[868]*work.d[643]*work.L[868]-work.L[869]*work.d[644]*work.L[869]-work.L[870]*work.d[785]*work.L[870]-work.L[876]*work.d[791]*work.L[876]-work.L[872]*work.d[787]*work.L[872]-work.L[875]*work.d[790]*work.L[875]-work.L[871]*work.d[786]*work.L[871]-work.L[873]*work.d[788]*work.L[873]-work.L[874]*work.d[789]*work.L[874];
residual += temp*temp;
temp = work.KKT[1536]-1*work.d[745]*1;
residual += temp*temp;
temp = work.KKT[1645]-1*work.d[794]*1-work.L[877]*work.d[542]*work.L[877]-work.L[878]*work.d[543]*work.L[878]-work.L[879]*work.d[787]*work.L[879]-work.L[884]*work.d[793]*work.L[884]-work.L[880]*work.d[788]*work.L[880]-work.L[883]*work.d[792]*work.L[883]-work.L[881]*work.d[789]*work.L[881]-work.L[882]*work.d[790]*work.L[882];
residual += temp*temp;
temp = work.KKT[1650]-1*work.d[798]*1-work.L[902]*work.d[647]*work.L[902]-work.L[903]*work.d[648]*work.L[903]-work.L[904]*work.d[791]*work.L[904]-work.L[910]*work.d[797]*work.L[910]-work.L[906]*work.d[793]*work.L[906]-work.L[909]*work.d[796]*work.L[909]-work.L[905]*work.d[792]*work.L[905]-work.L[907]*work.d[794]*work.L[907]-work.L[908]*work.d[795]*work.L[908];
residual += temp*temp;
temp = work.KKT[1539]-1*work.d[746]*1;
residual += temp*temp;
temp = work.KKT[1654]-1*work.d[800]*1-work.L[911]*work.d[546]*work.L[911]-work.L[912]*work.d[547]*work.L[912]-work.L[913]*work.d[793]*work.L[913]-work.L[918]*work.d[799]*work.L[918]-work.L[914]*work.d[794]*work.L[914]-work.L[917]*work.d[798]*work.L[917]-work.L[915]*work.d[795]*work.L[915]-work.L[916]*work.d[796]*work.L[916];
residual += temp*temp;
temp = work.KKT[1659]-1*work.d[804]*1-work.L[936]*work.d[651]*work.L[936]-work.L[937]*work.d[652]*work.L[937]-work.L[938]*work.d[797]*work.L[938]-work.L[944]*work.d[803]*work.L[944]-work.L[940]*work.d[799]*work.L[940]-work.L[943]*work.d[802]*work.L[943]-work.L[939]*work.d[798]*work.L[939]-work.L[941]*work.d[800]*work.L[941]-work.L[942]*work.d[801]*work.L[942];
residual += temp*temp;
temp = work.KKT[1542]-1*work.d[747]*1;
residual += temp*temp;
temp = work.KKT[1663]-1*work.d[806]*1-work.L[945]*work.d[550]*work.L[945]-work.L[946]*work.d[551]*work.L[946]-work.L[947]*work.d[799]*work.L[947]-work.L[952]*work.d[805]*work.L[952]-work.L[948]*work.d[800]*work.L[948]-work.L[951]*work.d[804]*work.L[951]-work.L[949]*work.d[801]*work.L[949]-work.L[950]*work.d[802]*work.L[950];
residual += temp*temp;
temp = work.KKT[1668]-1*work.d[810]*1-work.L[970]*work.d[655]*work.L[970]-work.L[971]*work.d[656]*work.L[971]-work.L[972]*work.d[803]*work.L[972]-work.L[978]*work.d[809]*work.L[978]-work.L[974]*work.d[805]*work.L[974]-work.L[977]*work.d[808]*work.L[977]-work.L[973]*work.d[804]*work.L[973]-work.L[975]*work.d[806]*work.L[975]-work.L[976]*work.d[807]*work.L[976];
residual += temp*temp;
temp = work.KKT[1545]-1*work.d[748]*1;
residual += temp*temp;
temp = work.KKT[1672]-1*work.d[812]*1-work.L[979]*work.d[554]*work.L[979]-work.L[980]*work.d[555]*work.L[980]-work.L[981]*work.d[805]*work.L[981]-work.L[986]*work.d[811]*work.L[986]-work.L[982]*work.d[806]*work.L[982]-work.L[985]*work.d[810]*work.L[985]-work.L[983]*work.d[807]*work.L[983]-work.L[984]*work.d[808]*work.L[984];
residual += temp*temp;
temp = work.KKT[1677]-1*work.d[816]*1-work.L[1004]*work.d[659]*work.L[1004]-work.L[1005]*work.d[660]*work.L[1005]-work.L[1006]*work.d[809]*work.L[1006]-work.L[1012]*work.d[815]*work.L[1012]-work.L[1008]*work.d[811]*work.L[1008]-work.L[1011]*work.d[814]*work.L[1011]-work.L[1007]*work.d[810]*work.L[1007]-work.L[1009]*work.d[812]*work.L[1009]-work.L[1010]*work.d[813]*work.L[1010];
residual += temp*temp;
temp = work.KKT[1548]-1*work.d[749]*1;
residual += temp*temp;
temp = work.KKT[1681]-1*work.d[818]*1-work.L[1013]*work.d[558]*work.L[1013]-work.L[1014]*work.d[559]*work.L[1014]-work.L[1015]*work.d[811]*work.L[1015]-work.L[1020]*work.d[817]*work.L[1020]-work.L[1016]*work.d[812]*work.L[1016]-work.L[1019]*work.d[816]*work.L[1019]-work.L[1017]*work.d[813]*work.L[1017]-work.L[1018]*work.d[814]*work.L[1018];
residual += temp*temp;
temp = work.KKT[1686]-1*work.d[822]*1-work.L[1038]*work.d[663]*work.L[1038]-work.L[1039]*work.d[664]*work.L[1039]-work.L[1040]*work.d[815]*work.L[1040]-work.L[1046]*work.d[821]*work.L[1046]-work.L[1042]*work.d[817]*work.L[1042]-work.L[1045]*work.d[820]*work.L[1045]-work.L[1041]*work.d[816]*work.L[1041]-work.L[1043]*work.d[818]*work.L[1043]-work.L[1044]*work.d[819]*work.L[1044];
residual += temp*temp;
temp = work.KKT[1551]-1*work.d[750]*1;
residual += temp*temp;
temp = work.KKT[1690]-1*work.d[824]*1-work.L[1047]*work.d[562]*work.L[1047]-work.L[1048]*work.d[563]*work.L[1048]-work.L[1049]*work.d[817]*work.L[1049]-work.L[1054]*work.d[823]*work.L[1054]-work.L[1050]*work.d[818]*work.L[1050]-work.L[1053]*work.d[822]*work.L[1053]-work.L[1051]*work.d[819]*work.L[1051]-work.L[1052]*work.d[820]*work.L[1052];
residual += temp*temp;
temp = work.KKT[1695]-1*work.d[828]*1-work.L[1072]*work.d[667]*work.L[1072]-work.L[1073]*work.d[668]*work.L[1073]-work.L[1074]*work.d[821]*work.L[1074]-work.L[1080]*work.d[827]*work.L[1080]-work.L[1076]*work.d[823]*work.L[1076]-work.L[1079]*work.d[826]*work.L[1079]-work.L[1075]*work.d[822]*work.L[1075]-work.L[1077]*work.d[824]*work.L[1077]-work.L[1078]*work.d[825]*work.L[1078];
residual += temp*temp;
temp = work.KKT[1554]-1*work.d[751]*1;
residual += temp*temp;
temp = work.KKT[1699]-1*work.d[830]*1-work.L[1081]*work.d[566]*work.L[1081]-work.L[1082]*work.d[567]*work.L[1082]-work.L[1083]*work.d[823]*work.L[1083]-work.L[1088]*work.d[829]*work.L[1088]-work.L[1084]*work.d[824]*work.L[1084]-work.L[1087]*work.d[828]*work.L[1087]-work.L[1085]*work.d[825]*work.L[1085]-work.L[1086]*work.d[826]*work.L[1086];
residual += temp*temp;
temp = work.KKT[1704]-1*work.d[834]*1-work.L[1106]*work.d[671]*work.L[1106]-work.L[1107]*work.d[672]*work.L[1107]-work.L[1108]*work.d[827]*work.L[1108]-work.L[1114]*work.d[833]*work.L[1114]-work.L[1110]*work.d[829]*work.L[1110]-work.L[1113]*work.d[832]*work.L[1113]-work.L[1109]*work.d[828]*work.L[1109]-work.L[1111]*work.d[830]*work.L[1111]-work.L[1112]*work.d[831]*work.L[1112];
residual += temp*temp;
temp = work.KKT[1557]-1*work.d[752]*1;
residual += temp*temp;
temp = work.KKT[1708]-1*work.d[836]*1-work.L[1115]*work.d[570]*work.L[1115]-work.L[1116]*work.d[571]*work.L[1116]-work.L[1117]*work.d[829]*work.L[1117]-work.L[1122]*work.d[835]*work.L[1122]-work.L[1118]*work.d[830]*work.L[1118]-work.L[1121]*work.d[834]*work.L[1121]-work.L[1119]*work.d[831]*work.L[1119]-work.L[1120]*work.d[832]*work.L[1120];
residual += temp*temp;
temp = work.KKT[1713]-1*work.d[840]*1-work.L[1140]*work.d[675]*work.L[1140]-work.L[1141]*work.d[676]*work.L[1141]-work.L[1142]*work.d[833]*work.L[1142]-work.L[1148]*work.d[839]*work.L[1148]-work.L[1144]*work.d[835]*work.L[1144]-work.L[1147]*work.d[838]*work.L[1147]-work.L[1143]*work.d[834]*work.L[1143]-work.L[1145]*work.d[836]*work.L[1145]-work.L[1146]*work.d[837]*work.L[1146];
residual += temp*temp;
temp = work.KKT[1560]-1*work.d[753]*1;
residual += temp*temp;
temp = work.KKT[1717]-1*work.d[842]*1-work.L[1149]*work.d[574]*work.L[1149]-work.L[1150]*work.d[575]*work.L[1150]-work.L[1151]*work.d[835]*work.L[1151]-work.L[1156]*work.d[841]*work.L[1156]-work.L[1152]*work.d[836]*work.L[1152]-work.L[1155]*work.d[840]*work.L[1155]-work.L[1153]*work.d[837]*work.L[1153]-work.L[1154]*work.d[838]*work.L[1154];
residual += temp*temp;
temp = work.KKT[1722]-1*work.d[846]*1-work.L[1174]*work.d[679]*work.L[1174]-work.L[1175]*work.d[680]*work.L[1175]-work.L[1176]*work.d[839]*work.L[1176]-work.L[1182]*work.d[845]*work.L[1182]-work.L[1178]*work.d[841]*work.L[1178]-work.L[1181]*work.d[844]*work.L[1181]-work.L[1177]*work.d[840]*work.L[1177]-work.L[1179]*work.d[842]*work.L[1179]-work.L[1180]*work.d[843]*work.L[1180];
residual += temp*temp;
temp = work.KKT[1563]-1*work.d[754]*1;
residual += temp*temp;
temp = work.KKT[1726]-1*work.d[848]*1-work.L[1183]*work.d[578]*work.L[1183]-work.L[1184]*work.d[579]*work.L[1184]-work.L[1185]*work.d[841]*work.L[1185]-work.L[1190]*work.d[847]*work.L[1190]-work.L[1186]*work.d[842]*work.L[1186]-work.L[1189]*work.d[846]*work.L[1189]-work.L[1187]*work.d[843]*work.L[1187]-work.L[1188]*work.d[844]*work.L[1188];
residual += temp*temp;
temp = work.KKT[1731]-1*work.d[852]*1-work.L[1208]*work.d[683]*work.L[1208]-work.L[1209]*work.d[684]*work.L[1209]-work.L[1210]*work.d[845]*work.L[1210]-work.L[1216]*work.d[851]*work.L[1216]-work.L[1212]*work.d[847]*work.L[1212]-work.L[1215]*work.d[850]*work.L[1215]-work.L[1211]*work.d[846]*work.L[1211]-work.L[1213]*work.d[848]*work.L[1213]-work.L[1214]*work.d[849]*work.L[1214];
residual += temp*temp;
temp = work.KKT[1566]-1*work.d[755]*1;
residual += temp*temp;
temp = work.KKT[1735]-1*work.d[854]*1-work.L[1217]*work.d[582]*work.L[1217]-work.L[1218]*work.d[583]*work.L[1218]-work.L[1219]*work.d[847]*work.L[1219]-work.L[1224]*work.d[853]*work.L[1224]-work.L[1220]*work.d[848]*work.L[1220]-work.L[1223]*work.d[852]*work.L[1223]-work.L[1221]*work.d[849]*work.L[1221]-work.L[1222]*work.d[850]*work.L[1222];
residual += temp*temp;
temp = work.KKT[1740]-1*work.d[858]*1-work.L[1242]*work.d[687]*work.L[1242]-work.L[1243]*work.d[688]*work.L[1243]-work.L[1244]*work.d[851]*work.L[1244]-work.L[1250]*work.d[857]*work.L[1250]-work.L[1246]*work.d[853]*work.L[1246]-work.L[1249]*work.d[856]*work.L[1249]-work.L[1245]*work.d[852]*work.L[1245]-work.L[1247]*work.d[854]*work.L[1247]-work.L[1248]*work.d[855]*work.L[1248];
residual += temp*temp;
temp = work.KKT[1569]-1*work.d[756]*1;
residual += temp*temp;
temp = work.KKT[1744]-1*work.d[860]*1-work.L[1251]*work.d[586]*work.L[1251]-work.L[1252]*work.d[587]*work.L[1252]-work.L[1253]*work.d[853]*work.L[1253]-work.L[1258]*work.d[859]*work.L[1258]-work.L[1254]*work.d[854]*work.L[1254]-work.L[1257]*work.d[858]*work.L[1257]-work.L[1255]*work.d[855]*work.L[1255]-work.L[1256]*work.d[856]*work.L[1256];
residual += temp*temp;
temp = work.KKT[1749]-1*work.d[864]*1-work.L[1276]*work.d[691]*work.L[1276]-work.L[1277]*work.d[692]*work.L[1277]-work.L[1278]*work.d[857]*work.L[1278]-work.L[1284]*work.d[863]*work.L[1284]-work.L[1280]*work.d[859]*work.L[1280]-work.L[1283]*work.d[862]*work.L[1283]-work.L[1279]*work.d[858]*work.L[1279]-work.L[1281]*work.d[860]*work.L[1281]-work.L[1282]*work.d[861]*work.L[1282];
residual += temp*temp;
temp = work.KKT[1572]-1*work.d[757]*1;
residual += temp*temp;
temp = work.KKT[1753]-1*work.d[866]*1-work.L[1285]*work.d[590]*work.L[1285]-work.L[1286]*work.d[591]*work.L[1286]-work.L[1287]*work.d[859]*work.L[1287]-work.L[1292]*work.d[865]*work.L[1292]-work.L[1288]*work.d[860]*work.L[1288]-work.L[1291]*work.d[864]*work.L[1291]-work.L[1289]*work.d[861]*work.L[1289]-work.L[1290]*work.d[862]*work.L[1290];
residual += temp*temp;
temp = work.KKT[1758]-1*work.d[870]*1-work.L[1310]*work.d[695]*work.L[1310]-work.L[1311]*work.d[696]*work.L[1311]-work.L[1312]*work.d[863]*work.L[1312]-work.L[1318]*work.d[869]*work.L[1318]-work.L[1314]*work.d[865]*work.L[1314]-work.L[1317]*work.d[868]*work.L[1317]-work.L[1313]*work.d[864]*work.L[1313]-work.L[1315]*work.d[866]*work.L[1315]-work.L[1316]*work.d[867]*work.L[1316];
residual += temp*temp;
temp = work.KKT[1575]-1*work.d[758]*1;
residual += temp*temp;
temp = work.KKT[1762]-1*work.d[872]*1-work.L[1319]*work.d[594]*work.L[1319]-work.L[1320]*work.d[595]*work.L[1320]-work.L[1321]*work.d[865]*work.L[1321]-work.L[1326]*work.d[871]*work.L[1326]-work.L[1322]*work.d[866]*work.L[1322]-work.L[1325]*work.d[870]*work.L[1325]-work.L[1323]*work.d[867]*work.L[1323]-work.L[1324]*work.d[868]*work.L[1324];
residual += temp*temp;
temp = work.KKT[1767]-1*work.d[876]*1-work.L[1344]*work.d[699]*work.L[1344]-work.L[1345]*work.d[700]*work.L[1345]-work.L[1346]*work.d[869]*work.L[1346]-work.L[1352]*work.d[875]*work.L[1352]-work.L[1348]*work.d[871]*work.L[1348]-work.L[1351]*work.d[874]*work.L[1351]-work.L[1347]*work.d[870]*work.L[1347]-work.L[1349]*work.d[872]*work.L[1349]-work.L[1350]*work.d[873]*work.L[1350];
residual += temp*temp;
temp = work.KKT[1578]-1*work.d[759]*1;
residual += temp*temp;
temp = work.KKT[1771]-1*work.d[878]*1-work.L[1353]*work.d[598]*work.L[1353]-work.L[1354]*work.d[599]*work.L[1354]-work.L[1355]*work.d[871]*work.L[1355]-work.L[1360]*work.d[877]*work.L[1360]-work.L[1356]*work.d[872]*work.L[1356]-work.L[1359]*work.d[876]*work.L[1359]-work.L[1357]*work.d[873]*work.L[1357]-work.L[1358]*work.d[874]*work.L[1358];
residual += temp*temp;
temp = work.KKT[1776]-1*work.d[882]*1-work.L[1378]*work.d[703]*work.L[1378]-work.L[1379]*work.d[704]*work.L[1379]-work.L[1380]*work.d[875]*work.L[1380]-work.L[1386]*work.d[881]*work.L[1386]-work.L[1382]*work.d[877]*work.L[1382]-work.L[1385]*work.d[880]*work.L[1385]-work.L[1381]*work.d[876]*work.L[1381]-work.L[1383]*work.d[878]*work.L[1383]-work.L[1384]*work.d[879]*work.L[1384];
residual += temp*temp;
temp = work.KKT[1581]-1*work.d[760]*1;
residual += temp*temp;
temp = work.KKT[1780]-1*work.d[884]*1-work.L[1387]*work.d[602]*work.L[1387]-work.L[1388]*work.d[603]*work.L[1388]-work.L[1389]*work.d[877]*work.L[1389]-work.L[1394]*work.d[883]*work.L[1394]-work.L[1390]*work.d[878]*work.L[1390]-work.L[1393]*work.d[882]*work.L[1393]-work.L[1391]*work.d[879]*work.L[1391]-work.L[1392]*work.d[880]*work.L[1392];
residual += temp*temp;
temp = work.KKT[1785]-1*work.d[888]*1-work.L[1412]*work.d[707]*work.L[1412]-work.L[1413]*work.d[708]*work.L[1413]-work.L[1414]*work.d[881]*work.L[1414]-work.L[1420]*work.d[887]*work.L[1420]-work.L[1416]*work.d[883]*work.L[1416]-work.L[1419]*work.d[886]*work.L[1419]-work.L[1415]*work.d[882]*work.L[1415]-work.L[1417]*work.d[884]*work.L[1417]-work.L[1418]*work.d[885]*work.L[1418];
residual += temp*temp;
temp = work.KKT[1584]-1*work.d[761]*1;
residual += temp*temp;
temp = work.KKT[1789]-1*work.d[890]*1-work.L[1421]*work.d[606]*work.L[1421]-work.L[1422]*work.d[607]*work.L[1422]-work.L[1423]*work.d[883]*work.L[1423]-work.L[1428]*work.d[889]*work.L[1428]-work.L[1424]*work.d[884]*work.L[1424]-work.L[1427]*work.d[888]*work.L[1427]-work.L[1425]*work.d[885]*work.L[1425]-work.L[1426]*work.d[886]*work.L[1426];
residual += temp*temp;
temp = work.KKT[1794]-1*work.d[894]*1-work.L[1446]*work.d[711]*work.L[1446]-work.L[1447]*work.d[712]*work.L[1447]-work.L[1448]*work.d[887]*work.L[1448]-work.L[1454]*work.d[893]*work.L[1454]-work.L[1450]*work.d[889]*work.L[1450]-work.L[1453]*work.d[892]*work.L[1453]-work.L[1449]*work.d[888]*work.L[1449]-work.L[1451]*work.d[890]*work.L[1451]-work.L[1452]*work.d[891]*work.L[1452];
residual += temp*temp;
temp = work.KKT[1587]-1*work.d[762]*1;
residual += temp*temp;
temp = work.KKT[1798]-1*work.d[896]*1-work.L[1455]*work.d[610]*work.L[1455]-work.L[1456]*work.d[611]*work.L[1456]-work.L[1457]*work.d[889]*work.L[1457]-work.L[1462]*work.d[895]*work.L[1462]-work.L[1458]*work.d[890]*work.L[1458]-work.L[1461]*work.d[894]*work.L[1461]-work.L[1459]*work.d[891]*work.L[1459]-work.L[1460]*work.d[892]*work.L[1460];
residual += temp*temp;
temp = work.KKT[1803]-1*work.d[900]*1-work.L[1480]*work.d[715]*work.L[1480]-work.L[1481]*work.d[716]*work.L[1481]-work.L[1482]*work.d[893]*work.L[1482]-work.L[1488]*work.d[899]*work.L[1488]-work.L[1484]*work.d[895]*work.L[1484]-work.L[1487]*work.d[898]*work.L[1487]-work.L[1483]*work.d[894]*work.L[1483]-work.L[1485]*work.d[896]*work.L[1485]-work.L[1486]*work.d[897]*work.L[1486];
residual += temp*temp;
temp = work.KKT[1590]-1*work.d[763]*1;
residual += temp*temp;
temp = work.KKT[1810]-1*work.d[907]*1-work.L[1536]*work.d[614]*work.L[1536]-work.L[1537]*work.d[615]*work.L[1537]-work.L[1538]*work.d[895]*work.L[1538]-work.L[1546]*work.d[906]*work.L[1546]-work.L[1545]*work.d[905]*work.L[1545]-work.L[1539]*work.d[896]*work.L[1539]-work.L[1542]*work.d[900]*work.L[1542]-work.L[1540]*work.d[897]*work.L[1540]-work.L[1541]*work.d[898]*work.L[1541]-work.L[1543]*work.d[901]*work.L[1543]-work.L[1544]*work.d[904]*work.L[1544];
residual += temp*temp;
temp = work.KKT[1811]-1*work.d[908]*1-work.L[1547]*work.d[719]*work.L[1547]-work.L[1548]*work.d[720]*work.L[1548]-work.L[1550]*work.d[899]*work.L[1550]-work.L[1549]*work.d[774]*work.L[1549]-work.L[1556]*work.d[906]*work.L[1556]-work.L[1554]*work.d[904]*work.L[1554]-work.L[1553]*work.d[903]*work.L[1553]-work.L[1552]*work.d[901]*work.L[1552]-work.L[1551]*work.d[900]*work.L[1551]-work.L[1557]*work.d[907]*work.L[1557]-work.L[1555]*work.d[905]*work.L[1555];
residual += temp*temp;
temp = work.KKT[1593]-1*work.d[764]*1;
residual += temp*temp;
temp = work.KKT[1812]-1*work.d[909]*1-work.L[1558]*work.d[618]*work.L[1558]-work.L[1559]*work.d[619]*work.L[1559]-work.L[1566]*work.d[906]*work.L[1566]-work.L[1560]*work.d[775]*work.L[1560]-work.L[1561]*work.d[776]*work.L[1561]-work.L[1563]*work.d[903]*work.L[1563]-work.L[1562]*work.d[902]*work.L[1562]-work.L[1565]*work.d[905]*work.L[1565]-work.L[1564]*work.d[904]*work.L[1564]-work.L[1568]*work.d[908]*work.L[1568]-work.L[1567]*work.d[907]*work.L[1567];
residual += temp*temp;
temp = work.KKT[1805]-1*work.d[903]*1-work.L[1506]*work.d[723]*work.L[1506]-work.L[1507]*work.d[724]*work.L[1507]-work.L[1511]*work.d[774]*work.L[1511]-work.L[1508]*work.d[771]*work.L[1508]-work.L[1512]*work.d[775]*work.L[1512]-work.L[1509]*work.d[772]*work.L[1509]-work.L[1510]*work.d[773]*work.L[1510]-work.L[1513]*work.d[902]*work.L[1513];
residual += temp*temp;
temp = work.KKT[1596]-1*work.d[765]*1-work.L[755]*work.d[738]*work.L[755];
residual += temp*temp;
temp = work.KKT[1804]-1*work.d[902]*1-work.L[1498]*work.d[622]*work.L[1498]-work.L[1499]*work.d[623]*work.L[1499]-work.L[1504]*work.d[775]*work.L[1504]-work.L[1501]*work.d[739]*work.L[1501]-work.L[1500]*work.d[738]*work.L[1500]-work.L[1502]*work.d[765]*work.L[1502]-work.L[1503]*work.d[773]*work.L[1503]-work.L[1505]*work.d[776]*work.L[1505];
residual += temp*temp;
temp = work.KKT[1610]-1*work.d[773]*1-work.L[778]*work.d[727]*work.L[778]-work.L[779]*work.d[728]*work.L[779]-work.L[782]*work.d[771]*work.L[782]-work.L[781]*work.d[740]*work.L[781]-work.L[780]*work.d[739]*work.L[780]-work.L[783]*work.d[772]*work.L[783];
residual += temp*temp;
temp = work.KKT[628]-1*work.d[315]*1;
residual += temp*temp;
temp = work.KKT[1304]-1*work.d[628]*1-work.L[547]*work.d[626]*work.L[547]-work.L[548]*work.d[627]*work.L[548];
residual += temp*temp;
temp = work.KKT[1514]-1*work.d[733]*1-work.L[731]*work.d[731]*work.L[731]-work.L[732]*work.d[732]*work.L[732];
residual += temp*temp;
temp = work.KKT[0]-1*work.d[0]*1;
residual += temp*temp;
temp = work.KKT[2]-1*work.d[1]*1;
residual += temp*temp;
temp = work.KKT[4]-1*work.d[2]*1;
residual += temp*temp;
temp = work.KKT[6]-1*work.d[3]*1;
residual += temp*temp;
temp = work.KKT[8]-1*work.d[4]*1;
residual += temp*temp;
temp = work.KKT[10]-1*work.d[5]*1;
residual += temp*temp;
temp = work.KKT[12]-1*work.d[6]*1;
residual += temp*temp;
temp = work.KKT[14]-1*work.d[7]*1;
residual += temp*temp;
temp = work.KKT[16]-1*work.d[8]*1;
residual += temp*temp;
temp = work.KKT[18]-1*work.d[9]*1;
residual += temp*temp;
temp = work.KKT[20]-1*work.d[10]*1;
residual += temp*temp;
temp = work.KKT[22]-1*work.d[11]*1;
residual += temp*temp;
temp = work.KKT[24]-1*work.d[12]*1;
residual += temp*temp;
temp = work.KKT[26]-1*work.d[13]*1;
residual += temp*temp;
temp = work.KKT[28]-1*work.d[14]*1;
residual += temp*temp;
temp = work.KKT[30]-1*work.d[15]*1;
residual += temp*temp;
temp = work.KKT[32]-1*work.d[16]*1;
residual += temp*temp;
temp = work.KKT[34]-1*work.d[17]*1;
residual += temp*temp;
temp = work.KKT[36]-1*work.d[18]*1;
residual += temp*temp;
temp = work.KKT[38]-1*work.d[19]*1;
residual += temp*temp;
temp = work.KKT[40]-1*work.d[20]*1;
residual += temp*temp;
temp = work.KKT[42]-1*work.d[21]*1;
residual += temp*temp;
temp = work.KKT[44]-1*work.d[22]*1;
residual += temp*temp;
temp = work.KKT[46]-1*work.d[23]*1;
residual += temp*temp;
temp = work.KKT[48]-1*work.d[24]*1;
residual += temp*temp;
temp = work.KKT[50]-1*work.d[25]*1;
residual += temp*temp;
temp = work.KKT[52]-1*work.d[26]*1;
residual += temp*temp;
temp = work.KKT[54]-1*work.d[27]*1;
residual += temp*temp;
temp = work.KKT[56]-1*work.d[28]*1;
residual += temp*temp;
temp = work.KKT[58]-1*work.d[29]*1;
residual += temp*temp;
temp = work.KKT[60]-1*work.d[30]*1;
residual += temp*temp;
temp = work.KKT[62]-1*work.d[31]*1;
residual += temp*temp;
temp = work.KKT[64]-1*work.d[32]*1;
residual += temp*temp;
temp = work.KKT[66]-1*work.d[33]*1;
residual += temp*temp;
temp = work.KKT[68]-1*work.d[34]*1;
residual += temp*temp;
temp = work.KKT[70]-1*work.d[35]*1;
residual += temp*temp;
temp = work.KKT[72]-1*work.d[36]*1;
residual += temp*temp;
temp = work.KKT[74]-1*work.d[37]*1;
residual += temp*temp;
temp = work.KKT[76]-1*work.d[38]*1;
residual += temp*temp;
temp = work.KKT[78]-1*work.d[39]*1;
residual += temp*temp;
temp = work.KKT[80]-1*work.d[40]*1;
residual += temp*temp;
temp = work.KKT[82]-1*work.d[41]*1;
residual += temp*temp;
temp = work.KKT[84]-1*work.d[42]*1;
residual += temp*temp;
temp = work.KKT[86]-1*work.d[43]*1;
residual += temp*temp;
temp = work.KKT[88]-1*work.d[44]*1;
residual += temp*temp;
temp = work.KKT[90]-1*work.d[45]*1;
residual += temp*temp;
temp = work.KKT[92]-1*work.d[46]*1;
residual += temp*temp;
temp = work.KKT[94]-1*work.d[47]*1;
residual += temp*temp;
temp = work.KKT[96]-1*work.d[48]*1;
residual += temp*temp;
temp = work.KKT[98]-1*work.d[49]*1;
residual += temp*temp;
temp = work.KKT[100]-1*work.d[50]*1;
residual += temp*temp;
temp = work.KKT[102]-1*work.d[51]*1;
residual += temp*temp;
temp = work.KKT[104]-1*work.d[52]*1;
residual += temp*temp;
temp = work.KKT[106]-1*work.d[53]*1;
residual += temp*temp;
temp = work.KKT[108]-1*work.d[54]*1;
residual += temp*temp;
temp = work.KKT[110]-1*work.d[55]*1;
residual += temp*temp;
temp = work.KKT[112]-1*work.d[56]*1;
residual += temp*temp;
temp = work.KKT[114]-1*work.d[57]*1;
residual += temp*temp;
temp = work.KKT[116]-1*work.d[58]*1;
residual += temp*temp;
temp = work.KKT[118]-1*work.d[59]*1;
residual += temp*temp;
temp = work.KKT[120]-1*work.d[60]*1;
residual += temp*temp;
temp = work.KKT[122]-1*work.d[61]*1;
residual += temp*temp;
temp = work.KKT[124]-1*work.d[62]*1;
residual += temp*temp;
temp = work.KKT[126]-1*work.d[63]*1;
residual += temp*temp;
temp = work.KKT[128]-1*work.d[64]*1;
residual += temp*temp;
temp = work.KKT[130]-1*work.d[65]*1;
residual += temp*temp;
temp = work.KKT[132]-1*work.d[66]*1;
residual += temp*temp;
temp = work.KKT[134]-1*work.d[67]*1;
residual += temp*temp;
temp = work.KKT[136]-1*work.d[68]*1;
residual += temp*temp;
temp = work.KKT[138]-1*work.d[69]*1;
residual += temp*temp;
temp = work.KKT[140]-1*work.d[70]*1;
residual += temp*temp;
temp = work.KKT[142]-1*work.d[71]*1;
residual += temp*temp;
temp = work.KKT[144]-1*work.d[72]*1;
residual += temp*temp;
temp = work.KKT[146]-1*work.d[73]*1;
residual += temp*temp;
temp = work.KKT[148]-1*work.d[74]*1;
residual += temp*temp;
temp = work.KKT[150]-1*work.d[75]*1;
residual += temp*temp;
temp = work.KKT[152]-1*work.d[76]*1;
residual += temp*temp;
temp = work.KKT[154]-1*work.d[77]*1;
residual += temp*temp;
temp = work.KKT[156]-1*work.d[78]*1;
residual += temp*temp;
temp = work.KKT[158]-1*work.d[79]*1;
residual += temp*temp;
temp = work.KKT[160]-1*work.d[80]*1;
residual += temp*temp;
temp = work.KKT[162]-1*work.d[81]*1;
residual += temp*temp;
temp = work.KKT[164]-1*work.d[82]*1;
residual += temp*temp;
temp = work.KKT[166]-1*work.d[83]*1;
residual += temp*temp;
temp = work.KKT[168]-1*work.d[84]*1;
residual += temp*temp;
temp = work.KKT[170]-1*work.d[85]*1;
residual += temp*temp;
temp = work.KKT[172]-1*work.d[86]*1;
residual += temp*temp;
temp = work.KKT[174]-1*work.d[87]*1;
residual += temp*temp;
temp = work.KKT[176]-1*work.d[88]*1;
residual += temp*temp;
temp = work.KKT[178]-1*work.d[89]*1;
residual += temp*temp;
temp = work.KKT[180]-1*work.d[90]*1;
residual += temp*temp;
temp = work.KKT[182]-1*work.d[91]*1;
residual += temp*temp;
temp = work.KKT[184]-1*work.d[92]*1;
residual += temp*temp;
temp = work.KKT[186]-1*work.d[93]*1;
residual += temp*temp;
temp = work.KKT[188]-1*work.d[94]*1;
residual += temp*temp;
temp = work.KKT[190]-1*work.d[95]*1;
residual += temp*temp;
temp = work.KKT[192]-1*work.d[96]*1;
residual += temp*temp;
temp = work.KKT[194]-1*work.d[97]*1;
residual += temp*temp;
temp = work.KKT[196]-1*work.d[98]*1;
residual += temp*temp;
temp = work.KKT[198]-1*work.d[99]*1;
residual += temp*temp;
temp = work.KKT[200]-1*work.d[100]*1;
residual += temp*temp;
temp = work.KKT[202]-1*work.d[101]*1;
residual += temp*temp;
temp = work.KKT[204]-1*work.d[102]*1;
residual += temp*temp;
temp = work.KKT[206]-1*work.d[103]*1;
residual += temp*temp;
temp = work.KKT[208]-1*work.d[104]*1;
residual += temp*temp;
temp = work.KKT[210]-1*work.d[105]*1;
residual += temp*temp;
temp = work.KKT[212]-1*work.d[106]*1;
residual += temp*temp;
temp = work.KKT[214]-1*work.d[107]*1;
residual += temp*temp;
temp = work.KKT[216]-1*work.d[108]*1;
residual += temp*temp;
temp = work.KKT[218]-1*work.d[109]*1;
residual += temp*temp;
temp = work.KKT[220]-1*work.d[110]*1;
residual += temp*temp;
temp = work.KKT[222]-1*work.d[111]*1;
residual += temp*temp;
temp = work.KKT[224]-1*work.d[112]*1;
residual += temp*temp;
temp = work.KKT[226]-1*work.d[113]*1;
residual += temp*temp;
temp = work.KKT[228]-1*work.d[114]*1;
residual += temp*temp;
temp = work.KKT[230]-1*work.d[115]*1;
residual += temp*temp;
temp = work.KKT[232]-1*work.d[116]*1;
residual += temp*temp;
temp = work.KKT[234]-1*work.d[117]*1;
residual += temp*temp;
temp = work.KKT[236]-1*work.d[118]*1;
residual += temp*temp;
temp = work.KKT[238]-1*work.d[119]*1;
residual += temp*temp;
temp = work.KKT[240]-1*work.d[120]*1;
residual += temp*temp;
temp = work.KKT[242]-1*work.d[121]*1;
residual += temp*temp;
temp = work.KKT[244]-1*work.d[122]*1;
residual += temp*temp;
temp = work.KKT[246]-1*work.d[123]*1;
residual += temp*temp;
temp = work.KKT[248]-1*work.d[124]*1;
residual += temp*temp;
temp = work.KKT[250]-1*work.d[125]*1;
residual += temp*temp;
temp = work.KKT[252]-1*work.d[126]*1;
residual += temp*temp;
temp = work.KKT[254]-1*work.d[127]*1;
residual += temp*temp;
temp = work.KKT[256]-1*work.d[128]*1;
residual += temp*temp;
temp = work.KKT[258]-1*work.d[129]*1;
residual += temp*temp;
temp = work.KKT[260]-1*work.d[130]*1;
residual += temp*temp;
temp = work.KKT[262]-1*work.d[131]*1;
residual += temp*temp;
temp = work.KKT[264]-1*work.d[132]*1;
residual += temp*temp;
temp = work.KKT[266]-1*work.d[133]*1;
residual += temp*temp;
temp = work.KKT[268]-1*work.d[134]*1;
residual += temp*temp;
temp = work.KKT[270]-1*work.d[135]*1;
residual += temp*temp;
temp = work.KKT[272]-1*work.d[136]*1;
residual += temp*temp;
temp = work.KKT[274]-1*work.d[137]*1;
residual += temp*temp;
temp = work.KKT[276]-1*work.d[138]*1;
residual += temp*temp;
temp = work.KKT[278]-1*work.d[139]*1;
residual += temp*temp;
temp = work.KKT[280]-1*work.d[140]*1;
residual += temp*temp;
temp = work.KKT[282]-1*work.d[141]*1;
residual += temp*temp;
temp = work.KKT[284]-1*work.d[142]*1;
residual += temp*temp;
temp = work.KKT[286]-1*work.d[143]*1;
residual += temp*temp;
temp = work.KKT[288]-1*work.d[144]*1;
residual += temp*temp;
temp = work.KKT[290]-1*work.d[145]*1;
residual += temp*temp;
temp = work.KKT[292]-1*work.d[146]*1;
residual += temp*temp;
temp = work.KKT[294]-1*work.d[147]*1;
residual += temp*temp;
temp = work.KKT[296]-1*work.d[148]*1;
residual += temp*temp;
temp = work.KKT[298]-1*work.d[149]*1;
residual += temp*temp;
temp = work.KKT[300]-1*work.d[150]*1;
residual += temp*temp;
temp = work.KKT[302]-1*work.d[151]*1;
residual += temp*temp;
temp = work.KKT[304]-1*work.d[152]*1;
residual += temp*temp;
temp = work.KKT[306]-1*work.d[153]*1;
residual += temp*temp;
temp = work.KKT[308]-1*work.d[154]*1;
residual += temp*temp;
temp = work.KKT[310]-1*work.d[155]*1;
residual += temp*temp;
temp = work.KKT[312]-1*work.d[156]*1;
residual += temp*temp;
temp = work.KKT[314]-1*work.d[157]*1;
residual += temp*temp;
temp = work.KKT[316]-1*work.d[158]*1;
residual += temp*temp;
temp = work.KKT[318]-1*work.d[159]*1;
residual += temp*temp;
temp = work.KKT[320]-1*work.d[160]*1;
residual += temp*temp;
temp = work.KKT[322]-1*work.d[161]*1;
residual += temp*temp;
temp = work.KKT[324]-1*work.d[162]*1;
residual += temp*temp;
temp = work.KKT[326]-1*work.d[163]*1;
residual += temp*temp;
temp = work.KKT[328]-1*work.d[164]*1;
residual += temp*temp;
temp = work.KKT[330]-1*work.d[165]*1;
residual += temp*temp;
temp = work.KKT[332]-1*work.d[166]*1;
residual += temp*temp;
temp = work.KKT[334]-1*work.d[167]*1;
residual += temp*temp;
temp = work.KKT[336]-1*work.d[168]*1;
residual += temp*temp;
temp = work.KKT[338]-1*work.d[169]*1;
residual += temp*temp;
temp = work.KKT[340]-1*work.d[170]*1;
residual += temp*temp;
temp = work.KKT[342]-1*work.d[171]*1;
residual += temp*temp;
temp = work.KKT[344]-1*work.d[172]*1;
residual += temp*temp;
temp = work.KKT[346]-1*work.d[173]*1;
residual += temp*temp;
temp = work.KKT[348]-1*work.d[174]*1;
residual += temp*temp;
temp = work.KKT[350]-1*work.d[175]*1;
residual += temp*temp;
temp = work.KKT[352]-1*work.d[176]*1;
residual += temp*temp;
temp = work.KKT[354]-1*work.d[177]*1;
residual += temp*temp;
temp = work.KKT[356]-1*work.d[178]*1;
residual += temp*temp;
temp = work.KKT[358]-1*work.d[179]*1;
residual += temp*temp;
temp = work.KKT[360]-1*work.d[180]*1;
residual += temp*temp;
temp = work.KKT[362]-1*work.d[181]*1;
residual += temp*temp;
temp = work.KKT[364]-1*work.d[182]*1;
residual += temp*temp;
temp = work.KKT[366]-1*work.d[183]*1;
residual += temp*temp;
temp = work.KKT[368]-1*work.d[184]*1;
residual += temp*temp;
temp = work.KKT[370]-1*work.d[185]*1;
residual += temp*temp;
temp = work.KKT[372]-1*work.d[186]*1;
residual += temp*temp;
temp = work.KKT[374]-1*work.d[187]*1;
residual += temp*temp;
temp = work.KKT[376]-1*work.d[188]*1;
residual += temp*temp;
temp = work.KKT[378]-1*work.d[189]*1;
residual += temp*temp;
temp = work.KKT[380]-1*work.d[190]*1;
residual += temp*temp;
temp = work.KKT[382]-1*work.d[191]*1;
residual += temp*temp;
temp = work.KKT[384]-1*work.d[192]*1;
residual += temp*temp;
temp = work.KKT[386]-1*work.d[193]*1;
residual += temp*temp;
temp = work.KKT[388]-1*work.d[194]*1;
residual += temp*temp;
temp = work.KKT[390]-1*work.d[195]*1;
residual += temp*temp;
temp = work.KKT[392]-1*work.d[196]*1;
residual += temp*temp;
temp = work.KKT[394]-1*work.d[197]*1;
residual += temp*temp;
temp = work.KKT[396]-1*work.d[198]*1;
residual += temp*temp;
temp = work.KKT[398]-1*work.d[199]*1;
residual += temp*temp;
temp = work.KKT[400]-1*work.d[200]*1;
residual += temp*temp;
temp = work.KKT[402]-1*work.d[201]*1;
residual += temp*temp;
temp = work.KKT[404]-1*work.d[202]*1;
residual += temp*temp;
temp = work.KKT[406]-1*work.d[203]*1;
residual += temp*temp;
temp = work.KKT[408]-1*work.d[204]*1;
residual += temp*temp;
temp = work.KKT[410]-1*work.d[205]*1;
residual += temp*temp;
temp = work.KKT[412]-1*work.d[206]*1;
residual += temp*temp;
temp = work.KKT[414]-1*work.d[207]*1;
residual += temp*temp;
temp = work.KKT[416]-1*work.d[208]*1;
residual += temp*temp;
temp = work.KKT[418]-1*work.d[209]*1;
residual += temp*temp;
temp = work.KKT[420]-1*work.d[210]*1;
residual += temp*temp;
temp = work.KKT[422]-1*work.d[211]*1;
residual += temp*temp;
temp = work.KKT[424]-1*work.d[212]*1;
residual += temp*temp;
temp = work.KKT[426]-1*work.d[213]*1;
residual += temp*temp;
temp = work.KKT[428]-1*work.d[214]*1;
residual += temp*temp;
temp = work.KKT[430]-1*work.d[215]*1;
residual += temp*temp;
temp = work.KKT[432]-1*work.d[216]*1;
residual += temp*temp;
temp = work.KKT[434]-1*work.d[217]*1;
residual += temp*temp;
temp = work.KKT[436]-1*work.d[218]*1;
residual += temp*temp;
temp = work.KKT[438]-1*work.d[219]*1;
residual += temp*temp;
temp = work.KKT[440]-1*work.d[220]*1;
residual += temp*temp;
temp = work.KKT[442]-1*work.d[221]*1;
residual += temp*temp;
temp = work.KKT[444]-1*work.d[222]*1;
residual += temp*temp;
temp = work.KKT[446]-1*work.d[223]*1;
residual += temp*temp;
temp = work.KKT[448]-1*work.d[224]*1;
residual += temp*temp;
temp = work.KKT[450]-1*work.d[225]*1;
residual += temp*temp;
temp = work.KKT[452]-1*work.d[226]*1;
residual += temp*temp;
temp = work.KKT[454]-1*work.d[227]*1;
residual += temp*temp;
temp = work.KKT[456]-1*work.d[228]*1;
residual += temp*temp;
temp = work.KKT[458]-1*work.d[229]*1;
residual += temp*temp;
temp = work.KKT[460]-1*work.d[230]*1;
residual += temp*temp;
temp = work.KKT[462]-1*work.d[231]*1;
residual += temp*temp;
temp = work.KKT[464]-1*work.d[232]*1;
residual += temp*temp;
temp = work.KKT[466]-1*work.d[233]*1;
residual += temp*temp;
temp = work.KKT[468]-1*work.d[234]*1;
residual += temp*temp;
temp = work.KKT[470]-1*work.d[235]*1;
residual += temp*temp;
temp = work.KKT[472]-1*work.d[236]*1;
residual += temp*temp;
temp = work.KKT[474]-1*work.d[237]*1;
residual += temp*temp;
temp = work.KKT[476]-1*work.d[238]*1;
residual += temp*temp;
temp = work.KKT[478]-1*work.d[239]*1;
residual += temp*temp;
temp = work.KKT[480]-1*work.d[240]*1;
residual += temp*temp;
temp = work.KKT[482]-1*work.d[241]*1;
residual += temp*temp;
temp = work.KKT[484]-1*work.d[242]*1;
residual += temp*temp;
temp = work.KKT[486]-1*work.d[243]*1;
residual += temp*temp;
temp = work.KKT[488]-1*work.d[244]*1;
residual += temp*temp;
temp = work.KKT[490]-1*work.d[245]*1;
residual += temp*temp;
temp = work.KKT[492]-1*work.d[246]*1;
residual += temp*temp;
temp = work.KKT[494]-1*work.d[247]*1;
residual += temp*temp;
temp = work.KKT[496]-1*work.d[248]*1;
residual += temp*temp;
temp = work.KKT[498]-1*work.d[249]*1;
residual += temp*temp;
temp = work.KKT[500]-1*work.d[250]*1;
residual += temp*temp;
temp = work.KKT[502]-1*work.d[251]*1;
residual += temp*temp;
temp = work.KKT[504]-1*work.d[252]*1;
residual += temp*temp;
temp = work.KKT[506]-1*work.d[253]*1;
residual += temp*temp;
temp = work.KKT[508]-1*work.d[254]*1;
residual += temp*temp;
temp = work.KKT[510]-1*work.d[255]*1;
residual += temp*temp;
temp = work.KKT[512]-1*work.d[256]*1;
residual += temp*temp;
temp = work.KKT[514]-1*work.d[257]*1;
residual += temp*temp;
temp = work.KKT[516]-1*work.d[258]*1;
residual += temp*temp;
temp = work.KKT[518]-1*work.d[259]*1;
residual += temp*temp;
temp = work.KKT[520]-1*work.d[260]*1;
residual += temp*temp;
temp = work.KKT[522]-1*work.d[261]*1;
residual += temp*temp;
temp = work.KKT[524]-1*work.d[262]*1;
residual += temp*temp;
temp = work.KKT[526]-1*work.d[263]*1;
residual += temp*temp;
temp = work.KKT[528]-1*work.d[264]*1;
residual += temp*temp;
temp = work.KKT[530]-1*work.d[265]*1;
residual += temp*temp;
temp = work.KKT[532]-1*work.d[266]*1;
residual += temp*temp;
temp = work.KKT[534]-1*work.d[267]*1;
residual += temp*temp;
temp = work.KKT[536]-1*work.d[268]*1;
residual += temp*temp;
temp = work.KKT[538]-1*work.d[269]*1;
residual += temp*temp;
temp = work.KKT[540]-1*work.d[270]*1;
residual += temp*temp;
temp = work.KKT[542]-1*work.d[271]*1;
residual += temp*temp;
temp = work.KKT[544]-1*work.d[272]*1;
residual += temp*temp;
temp = work.KKT[546]-1*work.d[273]*1;
residual += temp*temp;
temp = work.KKT[548]-1*work.d[274]*1;
residual += temp*temp;
temp = work.KKT[550]-1*work.d[275]*1;
residual += temp*temp;
temp = work.KKT[552]-1*work.d[276]*1;
residual += temp*temp;
temp = work.KKT[554]-1*work.d[277]*1;
residual += temp*temp;
temp = work.KKT[556]-1*work.d[278]*1;
residual += temp*temp;
temp = work.KKT[558]-1*work.d[279]*1;
residual += temp*temp;
temp = work.KKT[560]-1*work.d[280]*1;
residual += temp*temp;
temp = work.KKT[562]-1*work.d[281]*1;
residual += temp*temp;
temp = work.KKT[564]-1*work.d[282]*1;
residual += temp*temp;
temp = work.KKT[566]-1*work.d[283]*1;
residual += temp*temp;
temp = work.KKT[568]-1*work.d[284]*1;
residual += temp*temp;
temp = work.KKT[570]-1*work.d[285]*1;
residual += temp*temp;
temp = work.KKT[572]-1*work.d[286]*1;
residual += temp*temp;
temp = work.KKT[574]-1*work.d[287]*1;
residual += temp*temp;
temp = work.KKT[576]-1*work.d[288]*1;
residual += temp*temp;
temp = work.KKT[578]-1*work.d[289]*1;
residual += temp*temp;
temp = work.KKT[580]-1*work.d[290]*1;
residual += temp*temp;
temp = work.KKT[582]-1*work.d[291]*1;
residual += temp*temp;
temp = work.KKT[584]-1*work.d[292]*1;
residual += temp*temp;
temp = work.KKT[586]-1*work.d[293]*1;
residual += temp*temp;
temp = work.KKT[588]-1*work.d[294]*1;
residual += temp*temp;
temp = work.KKT[590]-1*work.d[295]*1;
residual += temp*temp;
temp = work.KKT[592]-1*work.d[296]*1;
residual += temp*temp;
temp = work.KKT[594]-1*work.d[297]*1;
residual += temp*temp;
temp = work.KKT[596]-1*work.d[298]*1;
residual += temp*temp;
temp = work.KKT[598]-1*work.d[299]*1;
residual += temp*temp;
temp = work.KKT[600]-1*work.d[300]*1;
residual += temp*temp;
temp = work.KKT[602]-1*work.d[301]*1;
residual += temp*temp;
temp = work.KKT[604]-1*work.d[302]*1;
residual += temp*temp;
temp = work.KKT[606]-1*work.d[303]*1;
residual += temp*temp;
temp = work.KKT[608]-1*work.d[304]*1;
residual += temp*temp;
temp = work.KKT[610]-1*work.d[305]*1;
residual += temp*temp;
temp = work.KKT[612]-1*work.d[306]*1;
residual += temp*temp;
temp = work.KKT[614]-1*work.d[307]*1;
residual += temp*temp;
temp = work.KKT[616]-1*work.d[308]*1;
residual += temp*temp;
temp = work.KKT[618]-1*work.d[309]*1;
residual += temp*temp;
temp = work.KKT[620]-1*work.d[310]*1;
residual += temp*temp;
temp = work.KKT[622]-1*work.d[311]*1;
residual += temp*temp;
temp = work.KKT[1]-work.L[1]*work.d[0]*1;
residual += temp*temp;
temp = work.KKT[3]-work.L[3]*work.d[1]*1;
residual += temp*temp;
temp = work.KKT[5]-work.L[5]*work.d[2]*1;
residual += temp*temp;
temp = work.KKT[7]-work.L[8]*work.d[3]*1;
residual += temp*temp;
temp = work.KKT[9]-work.L[10]*work.d[4]*1;
residual += temp*temp;
temp = work.KKT[11]-work.L[12]*work.d[5]*1;
residual += temp*temp;
temp = work.KKT[13]-work.L[15]*work.d[6]*1;
residual += temp*temp;
temp = work.KKT[15]-work.L[17]*work.d[7]*1;
residual += temp*temp;
temp = work.KKT[17]-work.L[19]*work.d[8]*1;
residual += temp*temp;
temp = work.KKT[19]-work.L[22]*work.d[9]*1;
residual += temp*temp;
temp = work.KKT[21]-work.L[24]*work.d[10]*1;
residual += temp*temp;
temp = work.KKT[23]-work.L[26]*work.d[11]*1;
residual += temp*temp;
temp = work.KKT[25]-work.L[29]*work.d[12]*1;
residual += temp*temp;
temp = work.KKT[27]-work.L[31]*work.d[13]*1;
residual += temp*temp;
temp = work.KKT[29]-work.L[33]*work.d[14]*1;
residual += temp*temp;
temp = work.KKT[31]-work.L[36]*work.d[15]*1;
residual += temp*temp;
temp = work.KKT[33]-work.L[38]*work.d[16]*1;
residual += temp*temp;
temp = work.KKT[35]-work.L[40]*work.d[17]*1;
residual += temp*temp;
temp = work.KKT[37]-work.L[43]*work.d[18]*1;
residual += temp*temp;
temp = work.KKT[39]-work.L[45]*work.d[19]*1;
residual += temp*temp;
temp = work.KKT[41]-work.L[47]*work.d[20]*1;
residual += temp*temp;
temp = work.KKT[43]-work.L[50]*work.d[21]*1;
residual += temp*temp;
temp = work.KKT[45]-work.L[52]*work.d[22]*1;
residual += temp*temp;
temp = work.KKT[47]-work.L[54]*work.d[23]*1;
residual += temp*temp;
temp = work.KKT[49]-work.L[57]*work.d[24]*1;
residual += temp*temp;
temp = work.KKT[51]-work.L[59]*work.d[25]*1;
residual += temp*temp;
temp = work.KKT[53]-work.L[61]*work.d[26]*1;
residual += temp*temp;
temp = work.KKT[55]-work.L[64]*work.d[27]*1;
residual += temp*temp;
temp = work.KKT[57]-work.L[66]*work.d[28]*1;
residual += temp*temp;
temp = work.KKT[59]-work.L[68]*work.d[29]*1;
residual += temp*temp;
temp = work.KKT[61]-work.L[71]*work.d[30]*1;
residual += temp*temp;
temp = work.KKT[63]-work.L[73]*work.d[31]*1;
residual += temp*temp;
temp = work.KKT[65]-work.L[75]*work.d[32]*1;
residual += temp*temp;
temp = work.KKT[67]-work.L[78]*work.d[33]*1;
residual += temp*temp;
temp = work.KKT[69]-work.L[80]*work.d[34]*1;
residual += temp*temp;
temp = work.KKT[71]-work.L[82]*work.d[35]*1;
residual += temp*temp;
temp = work.KKT[73]-work.L[85]*work.d[36]*1;
residual += temp*temp;
temp = work.KKT[75]-work.L[87]*work.d[37]*1;
residual += temp*temp;
temp = work.KKT[77]-work.L[89]*work.d[38]*1;
residual += temp*temp;
temp = work.KKT[79]-work.L[92]*work.d[39]*1;
residual += temp*temp;
temp = work.KKT[81]-work.L[94]*work.d[40]*1;
residual += temp*temp;
temp = work.KKT[83]-work.L[96]*work.d[41]*1;
residual += temp*temp;
temp = work.KKT[85]-work.L[99]*work.d[42]*1;
residual += temp*temp;
temp = work.KKT[87]-work.L[101]*work.d[43]*1;
residual += temp*temp;
temp = work.KKT[89]-work.L[103]*work.d[44]*1;
residual += temp*temp;
temp = work.KKT[91]-work.L[106]*work.d[45]*1;
residual += temp*temp;
temp = work.KKT[93]-work.L[108]*work.d[46]*1;
residual += temp*temp;
temp = work.KKT[95]-work.L[110]*work.d[47]*1;
residual += temp*temp;
temp = work.KKT[97]-work.L[113]*work.d[48]*1;
residual += temp*temp;
temp = work.KKT[99]-work.L[115]*work.d[49]*1;
residual += temp*temp;
temp = work.KKT[101]-work.L[117]*work.d[50]*1;
residual += temp*temp;
temp = work.KKT[103]-work.L[120]*work.d[51]*1;
residual += temp*temp;
temp = work.KKT[105]-work.L[122]*work.d[52]*1;
residual += temp*temp;
temp = work.KKT[107]-work.L[124]*work.d[53]*1;
residual += temp*temp;
temp = work.KKT[109]-work.L[127]*work.d[54]*1;
residual += temp*temp;
temp = work.KKT[111]-work.L[129]*work.d[55]*1;
residual += temp*temp;
temp = work.KKT[113]-work.L[131]*work.d[56]*1;
residual += temp*temp;
temp = work.KKT[115]-work.L[134]*work.d[57]*1;
residual += temp*temp;
temp = work.KKT[117]-work.L[136]*work.d[58]*1;
residual += temp*temp;
temp = work.KKT[119]-work.L[138]*work.d[59]*1;
residual += temp*temp;
temp = work.KKT[121]-work.L[141]*work.d[60]*1;
residual += temp*temp;
temp = work.KKT[123]-work.L[143]*work.d[61]*1;
residual += temp*temp;
temp = work.KKT[125]-work.L[145]*work.d[62]*1;
residual += temp*temp;
temp = work.KKT[127]-work.L[148]*work.d[63]*1;
residual += temp*temp;
temp = work.KKT[129]-work.L[150]*work.d[64]*1;
residual += temp*temp;
temp = work.KKT[131]-work.L[152]*work.d[65]*1;
residual += temp*temp;
temp = work.KKT[133]-work.L[155]*work.d[66]*1;
residual += temp*temp;
temp = work.KKT[135]-work.L[157]*work.d[67]*1;
residual += temp*temp;
temp = work.KKT[137]-work.L[159]*work.d[68]*1;
residual += temp*temp;
temp = work.KKT[139]-work.L[162]*work.d[69]*1;
residual += temp*temp;
temp = work.KKT[141]-work.L[164]*work.d[70]*1;
residual += temp*temp;
temp = work.KKT[143]-work.L[166]*work.d[71]*1;
residual += temp*temp;
temp = work.KKT[145]-work.L[169]*work.d[72]*1;
residual += temp*temp;
temp = work.KKT[147]-work.L[171]*work.d[73]*1;
residual += temp*temp;
temp = work.KKT[149]-work.L[173]*work.d[74]*1;
residual += temp*temp;
temp = work.KKT[151]-work.L[176]*work.d[75]*1;
residual += temp*temp;
temp = work.KKT[153]-work.L[178]*work.d[76]*1;
residual += temp*temp;
temp = work.KKT[155]-work.L[180]*work.d[77]*1;
residual += temp*temp;
temp = work.KKT[157]-work.L[183]*work.d[78]*1;
residual += temp*temp;
temp = work.KKT[159]-work.L[185]*work.d[79]*1;
residual += temp*temp;
temp = work.KKT[161]-work.L[187]*work.d[80]*1;
residual += temp*temp;
temp = work.KKT[163]-work.L[190]*work.d[81]*1;
residual += temp*temp;
temp = work.KKT[165]-work.L[192]*work.d[82]*1;
residual += temp*temp;
temp = work.KKT[167]-work.L[194]*work.d[83]*1;
residual += temp*temp;
temp = work.KKT[169]-work.L[197]*work.d[84]*1;
residual += temp*temp;
temp = work.KKT[171]-work.L[199]*work.d[85]*1;
residual += temp*temp;
temp = work.KKT[173]-work.L[201]*work.d[86]*1;
residual += temp*temp;
temp = work.KKT[175]-work.L[204]*work.d[87]*1;
residual += temp*temp;
temp = work.KKT[177]-work.L[206]*work.d[88]*1;
residual += temp*temp;
temp = work.KKT[179]-work.L[208]*work.d[89]*1;
residual += temp*temp;
temp = work.KKT[181]-work.L[211]*work.d[90]*1;
residual += temp*temp;
temp = work.KKT[183]-work.L[213]*work.d[91]*1;
residual += temp*temp;
temp = work.KKT[185]-work.L[215]*work.d[92]*1;
residual += temp*temp;
temp = work.KKT[187]-work.L[218]*work.d[93]*1;
residual += temp*temp;
temp = work.KKT[189]-work.L[220]*work.d[94]*1;
residual += temp*temp;
temp = work.KKT[191]-work.L[222]*work.d[95]*1;
residual += temp*temp;
temp = work.KKT[193]-work.L[225]*work.d[96]*1;
residual += temp*temp;
temp = work.KKT[195]-work.L[227]*work.d[97]*1;
residual += temp*temp;
temp = work.KKT[197]-work.L[229]*work.d[98]*1;
residual += temp*temp;
temp = work.KKT[199]-work.L[232]*work.d[99]*1;
residual += temp*temp;
temp = work.KKT[201]-work.L[234]*work.d[100]*1;
residual += temp*temp;
temp = work.KKT[203]-work.L[236]*work.d[101]*1;
residual += temp*temp;
temp = work.KKT[205]-work.L[239]*work.d[102]*1;
residual += temp*temp;
temp = work.KKT[207]-work.L[241]*work.d[103]*1;
residual += temp*temp;
temp = work.KKT[209]-work.L[243]*work.d[104]*1;
residual += temp*temp;
temp = work.KKT[211]-work.L[246]*work.d[105]*1;
residual += temp*temp;
temp = work.KKT[213]-work.L[248]*work.d[106]*1;
residual += temp*temp;
temp = work.KKT[215]-work.L[250]*work.d[107]*1;
residual += temp*temp;
temp = work.KKT[217]-work.L[253]*work.d[108]*1;
residual += temp*temp;
temp = work.KKT[219]-work.L[255]*work.d[109]*1;
residual += temp*temp;
temp = work.KKT[221]-work.L[257]*work.d[110]*1;
residual += temp*temp;
temp = work.KKT[223]-work.L[260]*work.d[111]*1;
residual += temp*temp;
temp = work.KKT[225]-work.L[262]*work.d[112]*1;
residual += temp*temp;
temp = work.KKT[227]-work.L[264]*work.d[113]*1;
residual += temp*temp;
temp = work.KKT[229]-work.L[267]*work.d[114]*1;
residual += temp*temp;
temp = work.KKT[231]-work.L[269]*work.d[115]*1;
residual += temp*temp;
temp = work.KKT[233]-work.L[271]*work.d[116]*1;
residual += temp*temp;
temp = work.KKT[235]-work.L[274]*work.d[117]*1;
residual += temp*temp;
temp = work.KKT[237]-work.L[276]*work.d[118]*1;
residual += temp*temp;
temp = work.KKT[239]-work.L[278]*work.d[119]*1;
residual += temp*temp;
temp = work.KKT[241]-work.L[281]*work.d[120]*1;
residual += temp*temp;
temp = work.KKT[243]-work.L[283]*work.d[121]*1;
residual += temp*temp;
temp = work.KKT[245]-work.L[285]*work.d[122]*1;
residual += temp*temp;
temp = work.KKT[247]-work.L[288]*work.d[123]*1;
residual += temp*temp;
temp = work.KKT[249]-work.L[290]*work.d[124]*1;
residual += temp*temp;
temp = work.KKT[251]-work.L[292]*work.d[125]*1;
residual += temp*temp;
temp = work.KKT[253]-work.L[295]*work.d[126]*1;
residual += temp*temp;
temp = work.KKT[255]-work.L[297]*work.d[127]*1;
residual += temp*temp;
temp = work.KKT[257]-work.L[299]*work.d[128]*1;
residual += temp*temp;
temp = work.KKT[259]-work.L[302]*work.d[129]*1;
residual += temp*temp;
temp = work.KKT[261]-work.L[304]*work.d[130]*1;
residual += temp*temp;
temp = work.KKT[263]-work.L[306]*work.d[131]*1;
residual += temp*temp;
temp = work.KKT[265]-work.L[309]*work.d[132]*1;
residual += temp*temp;
temp = work.KKT[267]-work.L[311]*work.d[133]*1;
residual += temp*temp;
temp = work.KKT[269]-work.L[313]*work.d[134]*1;
residual += temp*temp;
temp = work.KKT[271]-work.L[316]*work.d[135]*1;
residual += temp*temp;
temp = work.KKT[273]-work.L[318]*work.d[136]*1;
residual += temp*temp;
temp = work.KKT[275]-work.L[320]*work.d[137]*1;
residual += temp*temp;
temp = work.KKT[277]-work.L[323]*work.d[138]*1;
residual += temp*temp;
temp = work.KKT[279]-work.L[325]*work.d[139]*1;
residual += temp*temp;
temp = work.KKT[281]-work.L[327]*work.d[140]*1;
residual += temp*temp;
temp = work.KKT[283]-work.L[330]*work.d[141]*1;
residual += temp*temp;
temp = work.KKT[285]-work.L[332]*work.d[142]*1;
residual += temp*temp;
temp = work.KKT[287]-work.L[334]*work.d[143]*1;
residual += temp*temp;
temp = work.KKT[289]-work.L[337]*work.d[144]*1;
residual += temp*temp;
temp = work.KKT[291]-work.L[339]*work.d[145]*1;
residual += temp*temp;
temp = work.KKT[293]-work.L[341]*work.d[146]*1;
residual += temp*temp;
temp = work.KKT[295]-work.L[344]*work.d[147]*1;
residual += temp*temp;
temp = work.KKT[297]-work.L[346]*work.d[148]*1;
residual += temp*temp;
temp = work.KKT[299]-work.L[348]*work.d[149]*1;
residual += temp*temp;
temp = work.KKT[301]-work.L[351]*work.d[150]*1;
residual += temp*temp;
temp = work.KKT[303]-work.L[353]*work.d[151]*1;
residual += temp*temp;
temp = work.KKT[305]-work.L[355]*work.d[152]*1;
residual += temp*temp;
temp = work.KKT[307]-work.L[358]*work.d[153]*1;
residual += temp*temp;
temp = work.KKT[309]-work.L[360]*work.d[154]*1;
residual += temp*temp;
temp = work.KKT[311]-work.L[362]*work.d[155]*1;
residual += temp*temp;
temp = work.KKT[313]-work.L[365]*work.d[156]*1;
residual += temp*temp;
temp = work.KKT[315]-work.L[367]*work.d[157]*1;
residual += temp*temp;
temp = work.KKT[317]-work.L[369]*work.d[158]*1;
residual += temp*temp;
temp = work.KKT[319]-work.L[372]*work.d[159]*1;
residual += temp*temp;
temp = work.KKT[321]-work.L[374]*work.d[160]*1;
residual += temp*temp;
temp = work.KKT[323]-work.L[376]*work.d[161]*1;
residual += temp*temp;
temp = work.KKT[325]-work.L[379]*work.d[162]*1;
residual += temp*temp;
temp = work.KKT[327]-work.L[381]*work.d[163]*1;
residual += temp*temp;
temp = work.KKT[329]-work.L[383]*work.d[164]*1;
residual += temp*temp;
temp = work.KKT[331]-work.L[386]*work.d[165]*1;
residual += temp*temp;
temp = work.KKT[333]-work.L[388]*work.d[166]*1;
residual += temp*temp;
temp = work.KKT[335]-work.L[390]*work.d[167]*1;
residual += temp*temp;
temp = work.KKT[337]-work.L[393]*work.d[168]*1;
residual += temp*temp;
temp = work.KKT[339]-work.L[395]*work.d[169]*1;
residual += temp*temp;
temp = work.KKT[341]-work.L[397]*work.d[170]*1;
residual += temp*temp;
temp = work.KKT[343]-work.L[400]*work.d[171]*1;
residual += temp*temp;
temp = work.KKT[345]-work.L[402]*work.d[172]*1;
residual += temp*temp;
temp = work.KKT[347]-work.L[404]*work.d[173]*1;
residual += temp*temp;
temp = work.KKT[349]-work.L[407]*work.d[174]*1;
residual += temp*temp;
temp = work.KKT[351]-work.L[409]*work.d[175]*1;
residual += temp*temp;
temp = work.KKT[353]-work.L[411]*work.d[176]*1;
residual += temp*temp;
temp = work.KKT[355]-work.L[414]*work.d[177]*1;
residual += temp*temp;
temp = work.KKT[357]-work.L[416]*work.d[178]*1;
residual += temp*temp;
temp = work.KKT[359]-work.L[418]*work.d[179]*1;
residual += temp*temp;
temp = work.KKT[361]-work.L[421]*work.d[180]*1;
residual += temp*temp;
temp = work.KKT[363]-work.L[423]*work.d[181]*1;
residual += temp*temp;
temp = work.KKT[365]-work.L[425]*work.d[182]*1;
residual += temp*temp;
temp = work.KKT[367]-work.L[428]*work.d[183]*1;
residual += temp*temp;
temp = work.KKT[369]-work.L[430]*work.d[184]*1;
residual += temp*temp;
temp = work.KKT[371]-work.L[432]*work.d[185]*1;
residual += temp*temp;
temp = work.KKT[373]-work.L[435]*work.d[186]*1;
residual += temp*temp;
temp = work.KKT[375]-work.L[437]*work.d[187]*1;
residual += temp*temp;
temp = work.KKT[377]-work.L[439]*work.d[188]*1;
residual += temp*temp;
temp = work.KKT[379]-work.L[442]*work.d[189]*1;
residual += temp*temp;
temp = work.KKT[381]-work.L[444]*work.d[190]*1;
residual += temp*temp;
temp = work.KKT[383]-work.L[446]*work.d[191]*1;
residual += temp*temp;
temp = work.KKT[385]-work.L[449]*work.d[192]*1;
residual += temp*temp;
temp = work.KKT[387]-work.L[451]*work.d[193]*1;
residual += temp*temp;
temp = work.KKT[389]-work.L[453]*work.d[194]*1;
residual += temp*temp;
temp = work.KKT[391]-work.L[456]*work.d[195]*1;
residual += temp*temp;
temp = work.KKT[393]-work.L[458]*work.d[196]*1;
residual += temp*temp;
temp = work.KKT[395]-work.L[460]*work.d[197]*1;
residual += temp*temp;
temp = work.KKT[397]-work.L[463]*work.d[198]*1;
residual += temp*temp;
temp = work.KKT[399]-work.L[465]*work.d[199]*1;
residual += temp*temp;
temp = work.KKT[401]-work.L[467]*work.d[200]*1;
residual += temp*temp;
temp = work.KKT[403]-work.L[470]*work.d[201]*1;
residual += temp*temp;
temp = work.KKT[405]-work.L[472]*work.d[202]*1;
residual += temp*temp;
temp = work.KKT[407]-work.L[474]*work.d[203]*1;
residual += temp*temp;
temp = work.KKT[409]-work.L[477]*work.d[204]*1;
residual += temp*temp;
temp = work.KKT[411]-work.L[479]*work.d[205]*1;
residual += temp*temp;
temp = work.KKT[413]-work.L[481]*work.d[206]*1;
residual += temp*temp;
temp = work.KKT[415]-work.L[484]*work.d[207]*1;
residual += temp*temp;
temp = work.KKT[417]-work.L[486]*work.d[208]*1;
residual += temp*temp;
temp = work.KKT[419]-work.L[488]*work.d[209]*1;
residual += temp*temp;
temp = work.KKT[421]-work.L[491]*work.d[210]*1;
residual += temp*temp;
temp = work.KKT[423]-work.L[493]*work.d[211]*1;
residual += temp*temp;
temp = work.KKT[425]-work.L[495]*work.d[212]*1;
residual += temp*temp;
temp = work.KKT[427]-work.L[498]*work.d[213]*1;
residual += temp*temp;
temp = work.KKT[429]-work.L[500]*work.d[214]*1;
residual += temp*temp;
temp = work.KKT[431]-work.L[502]*work.d[215]*1;
residual += temp*temp;
temp = work.KKT[433]-work.L[505]*work.d[216]*1;
residual += temp*temp;
temp = work.KKT[435]-work.L[507]*work.d[217]*1;
residual += temp*temp;
temp = work.KKT[437]-work.L[509]*work.d[218]*1;
residual += temp*temp;
temp = work.KKT[439]-work.L[512]*work.d[219]*1;
residual += temp*temp;
temp = work.KKT[441]-work.L[514]*work.d[220]*1;
residual += temp*temp;
temp = work.KKT[443]-work.L[516]*work.d[221]*1;
residual += temp*temp;
temp = work.KKT[445]-work.L[519]*work.d[222]*1;
residual += temp*temp;
temp = work.KKT[447]-work.L[521]*work.d[223]*1;
residual += temp*temp;
temp = work.KKT[449]-work.L[523]*work.d[224]*1;
residual += temp*temp;
temp = work.KKT[451]-work.L[526]*work.d[225]*1;
residual += temp*temp;
temp = work.KKT[453]-work.L[528]*work.d[226]*1;
residual += temp*temp;
temp = work.KKT[455]-work.L[530]*work.d[227]*1;
residual += temp*temp;
temp = work.KKT[457]-work.L[533]*work.d[228]*1;
residual += temp*temp;
temp = work.KKT[459]-work.L[535]*work.d[229]*1;
residual += temp*temp;
temp = work.KKT[461]-work.L[537]*work.d[230]*1;
residual += temp*temp;
temp = work.KKT[463]-work.L[540]*work.d[231]*1;
residual += temp*temp;
temp = work.KKT[465]-work.L[542]*work.d[232]*1;
residual += temp*temp;
temp = work.KKT[467]-work.L[544]*work.d[233]*1;
residual += temp*temp;
temp = work.KKT[469]-work.L[549]*work.d[234]*1;
residual += temp*temp;
temp = work.KKT[471]-work.L[551]*work.d[235]*1;
residual += temp*temp;
temp = work.KKT[473]-work.L[553]*work.d[236]*1;
residual += temp*temp;
temp = work.KKT[475]-work.L[556]*work.d[237]*1;
residual += temp*temp;
temp = work.KKT[477]-work.L[558]*work.d[238]*1;
residual += temp*temp;
temp = work.KKT[479]-work.L[560]*work.d[239]*1;
residual += temp*temp;
temp = work.KKT[481]-work.L[563]*work.d[240]*1;
residual += temp*temp;
temp = work.KKT[483]-work.L[565]*work.d[241]*1;
residual += temp*temp;
temp = work.KKT[485]-work.L[567]*work.d[242]*1;
residual += temp*temp;
temp = work.KKT[487]-work.L[570]*work.d[243]*1;
residual += temp*temp;
temp = work.KKT[489]-work.L[572]*work.d[244]*1;
residual += temp*temp;
temp = work.KKT[491]-work.L[574]*work.d[245]*1;
residual += temp*temp;
temp = work.KKT[493]-work.L[577]*work.d[246]*1;
residual += temp*temp;
temp = work.KKT[495]-work.L[579]*work.d[247]*1;
residual += temp*temp;
temp = work.KKT[497]-work.L[581]*work.d[248]*1;
residual += temp*temp;
temp = work.KKT[499]-work.L[584]*work.d[249]*1;
residual += temp*temp;
temp = work.KKT[501]-work.L[586]*work.d[250]*1;
residual += temp*temp;
temp = work.KKT[503]-work.L[588]*work.d[251]*1;
residual += temp*temp;
temp = work.KKT[505]-work.L[591]*work.d[252]*1;
residual += temp*temp;
temp = work.KKT[507]-work.L[593]*work.d[253]*1;
residual += temp*temp;
temp = work.KKT[509]-work.L[595]*work.d[254]*1;
residual += temp*temp;
temp = work.KKT[511]-work.L[598]*work.d[255]*1;
residual += temp*temp;
temp = work.KKT[513]-work.L[600]*work.d[256]*1;
residual += temp*temp;
temp = work.KKT[515]-work.L[602]*work.d[257]*1;
residual += temp*temp;
temp = work.KKT[517]-work.L[605]*work.d[258]*1;
residual += temp*temp;
temp = work.KKT[519]-work.L[607]*work.d[259]*1;
residual += temp*temp;
temp = work.KKT[521]-work.L[609]*work.d[260]*1;
residual += temp*temp;
temp = work.KKT[523]-work.L[612]*work.d[261]*1;
residual += temp*temp;
temp = work.KKT[525]-work.L[614]*work.d[262]*1;
residual += temp*temp;
temp = work.KKT[527]-work.L[616]*work.d[263]*1;
residual += temp*temp;
temp = work.KKT[529]-work.L[619]*work.d[264]*1;
residual += temp*temp;
temp = work.KKT[531]-work.L[621]*work.d[265]*1;
residual += temp*temp;
temp = work.KKT[533]-work.L[623]*work.d[266]*1;
residual += temp*temp;
temp = work.KKT[535]-work.L[626]*work.d[267]*1;
residual += temp*temp;
temp = work.KKT[537]-work.L[628]*work.d[268]*1;
residual += temp*temp;
temp = work.KKT[539]-work.L[630]*work.d[269]*1;
residual += temp*temp;
temp = work.KKT[541]-work.L[633]*work.d[270]*1;
residual += temp*temp;
temp = work.KKT[543]-work.L[635]*work.d[271]*1;
residual += temp*temp;
temp = work.KKT[545]-work.L[637]*work.d[272]*1;
residual += temp*temp;
temp = work.KKT[547]-work.L[640]*work.d[273]*1;
residual += temp*temp;
temp = work.KKT[549]-work.L[642]*work.d[274]*1;
residual += temp*temp;
temp = work.KKT[551]-work.L[644]*work.d[275]*1;
residual += temp*temp;
temp = work.KKT[553]-work.L[647]*work.d[276]*1;
residual += temp*temp;
temp = work.KKT[555]-work.L[649]*work.d[277]*1;
residual += temp*temp;
temp = work.KKT[557]-work.L[651]*work.d[278]*1;
residual += temp*temp;
temp = work.KKT[559]-work.L[654]*work.d[279]*1;
residual += temp*temp;
temp = work.KKT[561]-work.L[656]*work.d[280]*1;
residual += temp*temp;
temp = work.KKT[563]-work.L[658]*work.d[281]*1;
residual += temp*temp;
temp = work.KKT[565]-work.L[661]*work.d[282]*1;
residual += temp*temp;
temp = work.KKT[567]-work.L[663]*work.d[283]*1;
residual += temp*temp;
temp = work.KKT[569]-work.L[665]*work.d[284]*1;
residual += temp*temp;
temp = work.KKT[571]-work.L[668]*work.d[285]*1;
residual += temp*temp;
temp = work.KKT[573]-work.L[670]*work.d[286]*1;
residual += temp*temp;
temp = work.KKT[575]-work.L[672]*work.d[287]*1;
residual += temp*temp;
temp = work.KKT[577]-work.L[675]*work.d[288]*1;
residual += temp*temp;
temp = work.KKT[579]-work.L[677]*work.d[289]*1;
residual += temp*temp;
temp = work.KKT[581]-work.L[679]*work.d[290]*1;
residual += temp*temp;
temp = work.KKT[583]-work.L[682]*work.d[291]*1;
residual += temp*temp;
temp = work.KKT[585]-work.L[684]*work.d[292]*1;
residual += temp*temp;
temp = work.KKT[587]-work.L[686]*work.d[293]*1;
residual += temp*temp;
temp = work.KKT[589]-work.L[689]*work.d[294]*1;
residual += temp*temp;
temp = work.KKT[591]-work.L[691]*work.d[295]*1;
residual += temp*temp;
temp = work.KKT[593]-work.L[693]*work.d[296]*1;
residual += temp*temp;
temp = work.KKT[595]-work.L[696]*work.d[297]*1;
residual += temp*temp;
temp = work.KKT[597]-work.L[698]*work.d[298]*1;
residual += temp*temp;
temp = work.KKT[599]-work.L[700]*work.d[299]*1;
residual += temp*temp;
temp = work.KKT[601]-work.L[703]*work.d[300]*1;
residual += temp*temp;
temp = work.KKT[603]-work.L[705]*work.d[301]*1;
residual += temp*temp;
temp = work.KKT[605]-work.L[707]*work.d[302]*1;
residual += temp*temp;
temp = work.KKT[607]-work.L[710]*work.d[303]*1;
residual += temp*temp;
temp = work.KKT[609]-work.L[712]*work.d[304]*1;
residual += temp*temp;
temp = work.KKT[611]-work.L[714]*work.d[305]*1;
residual += temp*temp;
temp = work.KKT[613]-work.L[717]*work.d[306]*1;
residual += temp*temp;
temp = work.KKT[615]-work.L[719]*work.d[307]*1;
residual += temp*temp;
temp = work.KKT[617]-work.L[721]*work.d[308]*1;
residual += temp*temp;
temp = work.KKT[619]-work.L[724]*work.d[309]*1;
residual += temp*temp;
temp = work.KKT[621]-work.L[726]*work.d[310]*1;
residual += temp*temp;
temp = work.KKT[623]-work.L[728]*work.d[311]*1;
residual += temp*temp;
temp = work.KKT[630]-work.L[1]*work.d[0]*work.L[1]-1*work.d[316]*1;
residual += temp*temp;
temp = work.KKT[634]-work.L[3]*work.d[1]*work.L[3]-1*work.d[318]*1-work.L[4]*work.d[317]*work.L[4];
residual += temp*temp;
temp = work.KKT[636]-work.L[5]*work.d[2]*work.L[5]-1*work.d[319]*1-work.L[6]*work.d[317]*work.L[6]-work.L[7]*work.d[318]*work.L[7];
residual += temp*temp;
temp = work.KKT[638]-work.L[8]*work.d[3]*work.L[8]-1*work.d[320]*1;
residual += temp*temp;
temp = work.KKT[642]-work.L[10]*work.d[4]*work.L[10]-1*work.d[322]*1-work.L[11]*work.d[321]*work.L[11];
residual += temp*temp;
temp = work.KKT[644]-work.L[12]*work.d[5]*work.L[12]-1*work.d[323]*1-work.L[13]*work.d[321]*work.L[13]-work.L[14]*work.d[322]*work.L[14];
residual += temp*temp;
temp = work.KKT[646]-work.L[15]*work.d[6]*work.L[15]-1*work.d[324]*1;
residual += temp*temp;
temp = work.KKT[650]-work.L[17]*work.d[7]*work.L[17]-1*work.d[326]*1-work.L[18]*work.d[325]*work.L[18];
residual += temp*temp;
temp = work.KKT[652]-work.L[19]*work.d[8]*work.L[19]-1*work.d[327]*1-work.L[20]*work.d[325]*work.L[20]-work.L[21]*work.d[326]*work.L[21];
residual += temp*temp;
temp = work.KKT[654]-work.L[22]*work.d[9]*work.L[22]-1*work.d[328]*1;
residual += temp*temp;
temp = work.KKT[658]-work.L[24]*work.d[10]*work.L[24]-1*work.d[330]*1-work.L[25]*work.d[329]*work.L[25];
residual += temp*temp;
temp = work.KKT[660]-work.L[26]*work.d[11]*work.L[26]-1*work.d[331]*1-work.L[27]*work.d[329]*work.L[27]-work.L[28]*work.d[330]*work.L[28];
residual += temp*temp;
temp = work.KKT[662]-work.L[29]*work.d[12]*work.L[29]-1*work.d[332]*1;
residual += temp*temp;
temp = work.KKT[666]-work.L[31]*work.d[13]*work.L[31]-1*work.d[334]*1-work.L[32]*work.d[333]*work.L[32];
residual += temp*temp;
temp = work.KKT[668]-work.L[33]*work.d[14]*work.L[33]-1*work.d[335]*1-work.L[34]*work.d[333]*work.L[34]-work.L[35]*work.d[334]*work.L[35];
residual += temp*temp;
temp = work.KKT[670]-work.L[36]*work.d[15]*work.L[36]-1*work.d[336]*1;
residual += temp*temp;
temp = work.KKT[674]-work.L[38]*work.d[16]*work.L[38]-1*work.d[338]*1-work.L[39]*work.d[337]*work.L[39];
residual += temp*temp;
temp = work.KKT[676]-work.L[40]*work.d[17]*work.L[40]-1*work.d[339]*1-work.L[41]*work.d[337]*work.L[41]-work.L[42]*work.d[338]*work.L[42];
residual += temp*temp;
temp = work.KKT[678]-work.L[43]*work.d[18]*work.L[43]-1*work.d[340]*1;
residual += temp*temp;
temp = work.KKT[682]-work.L[45]*work.d[19]*work.L[45]-1*work.d[342]*1-work.L[46]*work.d[341]*work.L[46];
residual += temp*temp;
temp = work.KKT[684]-work.L[47]*work.d[20]*work.L[47]-1*work.d[343]*1-work.L[48]*work.d[341]*work.L[48]-work.L[49]*work.d[342]*work.L[49];
residual += temp*temp;
temp = work.KKT[686]-work.L[50]*work.d[21]*work.L[50]-1*work.d[344]*1;
residual += temp*temp;
temp = work.KKT[690]-work.L[52]*work.d[22]*work.L[52]-1*work.d[346]*1-work.L[53]*work.d[345]*work.L[53];
residual += temp*temp;
temp = work.KKT[692]-work.L[54]*work.d[23]*work.L[54]-1*work.d[347]*1-work.L[55]*work.d[345]*work.L[55]-work.L[56]*work.d[346]*work.L[56];
residual += temp*temp;
temp = work.KKT[694]-work.L[57]*work.d[24]*work.L[57]-1*work.d[348]*1;
residual += temp*temp;
temp = work.KKT[698]-work.L[59]*work.d[25]*work.L[59]-1*work.d[350]*1-work.L[60]*work.d[349]*work.L[60];
residual += temp*temp;
temp = work.KKT[700]-work.L[61]*work.d[26]*work.L[61]-1*work.d[351]*1-work.L[62]*work.d[349]*work.L[62]-work.L[63]*work.d[350]*work.L[63];
residual += temp*temp;
temp = work.KKT[702]-work.L[64]*work.d[27]*work.L[64]-1*work.d[352]*1;
residual += temp*temp;
temp = work.KKT[706]-work.L[66]*work.d[28]*work.L[66]-1*work.d[354]*1-work.L[67]*work.d[353]*work.L[67];
residual += temp*temp;
temp = work.KKT[708]-work.L[68]*work.d[29]*work.L[68]-1*work.d[355]*1-work.L[69]*work.d[353]*work.L[69]-work.L[70]*work.d[354]*work.L[70];
residual += temp*temp;
temp = work.KKT[710]-work.L[71]*work.d[30]*work.L[71]-1*work.d[356]*1;
residual += temp*temp;
temp = work.KKT[714]-work.L[73]*work.d[31]*work.L[73]-1*work.d[358]*1-work.L[74]*work.d[357]*work.L[74];
residual += temp*temp;
temp = work.KKT[716]-work.L[75]*work.d[32]*work.L[75]-1*work.d[359]*1-work.L[76]*work.d[357]*work.L[76]-work.L[77]*work.d[358]*work.L[77];
residual += temp*temp;
temp = work.KKT[718]-work.L[78]*work.d[33]*work.L[78]-1*work.d[360]*1;
residual += temp*temp;
temp = work.KKT[722]-work.L[80]*work.d[34]*work.L[80]-1*work.d[362]*1-work.L[81]*work.d[361]*work.L[81];
residual += temp*temp;
temp = work.KKT[724]-work.L[82]*work.d[35]*work.L[82]-1*work.d[363]*1-work.L[83]*work.d[361]*work.L[83]-work.L[84]*work.d[362]*work.L[84];
residual += temp*temp;
temp = work.KKT[726]-work.L[85]*work.d[36]*work.L[85]-1*work.d[364]*1;
residual += temp*temp;
temp = work.KKT[730]-work.L[87]*work.d[37]*work.L[87]-1*work.d[366]*1-work.L[88]*work.d[365]*work.L[88];
residual += temp*temp;
temp = work.KKT[732]-work.L[89]*work.d[38]*work.L[89]-1*work.d[367]*1-work.L[90]*work.d[365]*work.L[90]-work.L[91]*work.d[366]*work.L[91];
residual += temp*temp;
temp = work.KKT[734]-work.L[92]*work.d[39]*work.L[92]-1*work.d[368]*1;
residual += temp*temp;
temp = work.KKT[738]-work.L[94]*work.d[40]*work.L[94]-1*work.d[370]*1-work.L[95]*work.d[369]*work.L[95];
residual += temp*temp;
temp = work.KKT[740]-work.L[96]*work.d[41]*work.L[96]-1*work.d[371]*1-work.L[97]*work.d[369]*work.L[97]-work.L[98]*work.d[370]*work.L[98];
residual += temp*temp;
temp = work.KKT[742]-work.L[99]*work.d[42]*work.L[99]-1*work.d[372]*1;
residual += temp*temp;
temp = work.KKT[746]-work.L[101]*work.d[43]*work.L[101]-1*work.d[374]*1-work.L[102]*work.d[373]*work.L[102];
residual += temp*temp;
temp = work.KKT[748]-work.L[103]*work.d[44]*work.L[103]-1*work.d[375]*1-work.L[104]*work.d[373]*work.L[104]-work.L[105]*work.d[374]*work.L[105];
residual += temp*temp;
temp = work.KKT[750]-work.L[106]*work.d[45]*work.L[106]-1*work.d[376]*1;
residual += temp*temp;
temp = work.KKT[754]-work.L[108]*work.d[46]*work.L[108]-1*work.d[378]*1-work.L[109]*work.d[377]*work.L[109];
residual += temp*temp;
temp = work.KKT[756]-work.L[110]*work.d[47]*work.L[110]-1*work.d[379]*1-work.L[111]*work.d[377]*work.L[111]-work.L[112]*work.d[378]*work.L[112];
residual += temp*temp;
temp = work.KKT[758]-work.L[113]*work.d[48]*work.L[113]-1*work.d[380]*1;
residual += temp*temp;
temp = work.KKT[762]-work.L[115]*work.d[49]*work.L[115]-1*work.d[382]*1-work.L[116]*work.d[381]*work.L[116];
residual += temp*temp;
temp = work.KKT[764]-work.L[117]*work.d[50]*work.L[117]-1*work.d[383]*1-work.L[118]*work.d[381]*work.L[118]-work.L[119]*work.d[382]*work.L[119];
residual += temp*temp;
temp = work.KKT[766]-work.L[120]*work.d[51]*work.L[120]-1*work.d[384]*1;
residual += temp*temp;
temp = work.KKT[770]-work.L[122]*work.d[52]*work.L[122]-1*work.d[386]*1-work.L[123]*work.d[385]*work.L[123];
residual += temp*temp;
temp = work.KKT[772]-work.L[124]*work.d[53]*work.L[124]-1*work.d[387]*1-work.L[125]*work.d[385]*work.L[125]-work.L[126]*work.d[386]*work.L[126];
residual += temp*temp;
temp = work.KKT[774]-work.L[127]*work.d[54]*work.L[127]-1*work.d[388]*1;
residual += temp*temp;
temp = work.KKT[778]-work.L[129]*work.d[55]*work.L[129]-1*work.d[390]*1-work.L[130]*work.d[389]*work.L[130];
residual += temp*temp;
temp = work.KKT[780]-work.L[131]*work.d[56]*work.L[131]-1*work.d[391]*1-work.L[132]*work.d[389]*work.L[132]-work.L[133]*work.d[390]*work.L[133];
residual += temp*temp;
temp = work.KKT[782]-work.L[134]*work.d[57]*work.L[134]-1*work.d[392]*1;
residual += temp*temp;
temp = work.KKT[786]-work.L[136]*work.d[58]*work.L[136]-1*work.d[394]*1-work.L[137]*work.d[393]*work.L[137];
residual += temp*temp;
temp = work.KKT[788]-work.L[138]*work.d[59]*work.L[138]-1*work.d[395]*1-work.L[139]*work.d[393]*work.L[139]-work.L[140]*work.d[394]*work.L[140];
residual += temp*temp;
temp = work.KKT[790]-work.L[141]*work.d[60]*work.L[141]-1*work.d[396]*1;
residual += temp*temp;
temp = work.KKT[794]-work.L[143]*work.d[61]*work.L[143]-1*work.d[398]*1-work.L[144]*work.d[397]*work.L[144];
residual += temp*temp;
temp = work.KKT[796]-work.L[145]*work.d[62]*work.L[145]-1*work.d[399]*1-work.L[146]*work.d[397]*work.L[146]-work.L[147]*work.d[398]*work.L[147];
residual += temp*temp;
temp = work.KKT[798]-work.L[148]*work.d[63]*work.L[148]-1*work.d[400]*1;
residual += temp*temp;
temp = work.KKT[802]-work.L[150]*work.d[64]*work.L[150]-1*work.d[402]*1-work.L[151]*work.d[401]*work.L[151];
residual += temp*temp;
temp = work.KKT[804]-work.L[152]*work.d[65]*work.L[152]-1*work.d[403]*1-work.L[153]*work.d[401]*work.L[153]-work.L[154]*work.d[402]*work.L[154];
residual += temp*temp;
temp = work.KKT[806]-work.L[155]*work.d[66]*work.L[155]-1*work.d[404]*1;
residual += temp*temp;
temp = work.KKT[810]-work.L[157]*work.d[67]*work.L[157]-1*work.d[406]*1-work.L[158]*work.d[405]*work.L[158];
residual += temp*temp;
temp = work.KKT[812]-work.L[159]*work.d[68]*work.L[159]-1*work.d[407]*1-work.L[160]*work.d[405]*work.L[160]-work.L[161]*work.d[406]*work.L[161];
residual += temp*temp;
temp = work.KKT[814]-work.L[162]*work.d[69]*work.L[162]-1*work.d[408]*1;
residual += temp*temp;
temp = work.KKT[818]-work.L[164]*work.d[70]*work.L[164]-1*work.d[410]*1-work.L[165]*work.d[409]*work.L[165];
residual += temp*temp;
temp = work.KKT[820]-work.L[166]*work.d[71]*work.L[166]-1*work.d[411]*1-work.L[167]*work.d[409]*work.L[167]-work.L[168]*work.d[410]*work.L[168];
residual += temp*temp;
temp = work.KKT[822]-work.L[169]*work.d[72]*work.L[169]-1*work.d[412]*1;
residual += temp*temp;
temp = work.KKT[826]-work.L[171]*work.d[73]*work.L[171]-1*work.d[414]*1-work.L[172]*work.d[413]*work.L[172];
residual += temp*temp;
temp = work.KKT[828]-work.L[173]*work.d[74]*work.L[173]-1*work.d[415]*1-work.L[174]*work.d[413]*work.L[174]-work.L[175]*work.d[414]*work.L[175];
residual += temp*temp;
temp = work.KKT[830]-work.L[176]*work.d[75]*work.L[176]-1*work.d[416]*1;
residual += temp*temp;
temp = work.KKT[834]-work.L[178]*work.d[76]*work.L[178]-1*work.d[418]*1-work.L[179]*work.d[417]*work.L[179];
residual += temp*temp;
temp = work.KKT[836]-work.L[180]*work.d[77]*work.L[180]-1*work.d[419]*1-work.L[181]*work.d[417]*work.L[181]-work.L[182]*work.d[418]*work.L[182];
residual += temp*temp;
temp = work.KKT[838]-work.L[183]*work.d[78]*work.L[183]-1*work.d[420]*1;
residual += temp*temp;
temp = work.KKT[842]-work.L[185]*work.d[79]*work.L[185]-1*work.d[422]*1-work.L[186]*work.d[421]*work.L[186];
residual += temp*temp;
temp = work.KKT[844]-work.L[187]*work.d[80]*work.L[187]-1*work.d[423]*1-work.L[188]*work.d[421]*work.L[188]-work.L[189]*work.d[422]*work.L[189];
residual += temp*temp;
temp = work.KKT[846]-work.L[190]*work.d[81]*work.L[190]-1*work.d[424]*1;
residual += temp*temp;
temp = work.KKT[850]-work.L[192]*work.d[82]*work.L[192]-1*work.d[426]*1-work.L[193]*work.d[425]*work.L[193];
residual += temp*temp;
temp = work.KKT[853]-work.L[194]*work.d[83]*work.L[194]-1*work.d[427]*1-work.L[195]*work.d[425]*work.L[195]-work.L[196]*work.d[426]*work.L[196];
residual += temp*temp;
temp = work.KKT[856]-work.L[197]*work.d[84]*work.L[197]-1*work.d[428]*1;
residual += temp*temp;
temp = work.KKT[860]-work.L[199]*work.d[85]*work.L[199]-1*work.d[430]*1-work.L[200]*work.d[429]*work.L[200];
residual += temp*temp;
temp = work.KKT[863]-work.L[201]*work.d[86]*work.L[201]-1*work.d[431]*1-work.L[202]*work.d[429]*work.L[202]-work.L[203]*work.d[430]*work.L[203];
residual += temp*temp;
temp = work.KKT[866]-work.L[204]*work.d[87]*work.L[204]-1*work.d[432]*1;
residual += temp*temp;
temp = work.KKT[870]-work.L[206]*work.d[88]*work.L[206]-1*work.d[434]*1-work.L[207]*work.d[433]*work.L[207];
residual += temp*temp;
temp = work.KKT[873]-work.L[208]*work.d[89]*work.L[208]-1*work.d[435]*1-work.L[209]*work.d[433]*work.L[209]-work.L[210]*work.d[434]*work.L[210];
residual += temp*temp;
temp = work.KKT[876]-work.L[211]*work.d[90]*work.L[211]-1*work.d[436]*1;
residual += temp*temp;
temp = work.KKT[880]-work.L[213]*work.d[91]*work.L[213]-1*work.d[438]*1-work.L[214]*work.d[437]*work.L[214];
residual += temp*temp;
temp = work.KKT[883]-work.L[215]*work.d[92]*work.L[215]-1*work.d[439]*1-work.L[216]*work.d[437]*work.L[216]-work.L[217]*work.d[438]*work.L[217];
residual += temp*temp;
temp = work.KKT[886]-work.L[218]*work.d[93]*work.L[218]-1*work.d[440]*1;
residual += temp*temp;
temp = work.KKT[890]-work.L[220]*work.d[94]*work.L[220]-1*work.d[442]*1-work.L[221]*work.d[441]*work.L[221];
residual += temp*temp;
temp = work.KKT[893]-work.L[222]*work.d[95]*work.L[222]-1*work.d[443]*1-work.L[223]*work.d[441]*work.L[223]-work.L[224]*work.d[442]*work.L[224];
residual += temp*temp;
temp = work.KKT[896]-work.L[225]*work.d[96]*work.L[225]-1*work.d[444]*1;
residual += temp*temp;
temp = work.KKT[900]-work.L[227]*work.d[97]*work.L[227]-1*work.d[446]*1-work.L[228]*work.d[445]*work.L[228];
residual += temp*temp;
temp = work.KKT[903]-work.L[229]*work.d[98]*work.L[229]-1*work.d[447]*1-work.L[230]*work.d[445]*work.L[230]-work.L[231]*work.d[446]*work.L[231];
residual += temp*temp;
temp = work.KKT[906]-work.L[232]*work.d[99]*work.L[232]-1*work.d[448]*1;
residual += temp*temp;
temp = work.KKT[910]-work.L[234]*work.d[100]*work.L[234]-1*work.d[450]*1-work.L[235]*work.d[449]*work.L[235];
residual += temp*temp;
temp = work.KKT[913]-work.L[236]*work.d[101]*work.L[236]-1*work.d[451]*1-work.L[237]*work.d[449]*work.L[237]-work.L[238]*work.d[450]*work.L[238];
residual += temp*temp;
temp = work.KKT[916]-work.L[239]*work.d[102]*work.L[239]-1*work.d[452]*1;
residual += temp*temp;
temp = work.KKT[920]-work.L[241]*work.d[103]*work.L[241]-1*work.d[454]*1-work.L[242]*work.d[453]*work.L[242];
residual += temp*temp;
temp = work.KKT[923]-work.L[243]*work.d[104]*work.L[243]-1*work.d[455]*1-work.L[244]*work.d[453]*work.L[244]-work.L[245]*work.d[454]*work.L[245];
residual += temp*temp;
temp = work.KKT[926]-work.L[246]*work.d[105]*work.L[246]-1*work.d[456]*1;
residual += temp*temp;
temp = work.KKT[930]-work.L[248]*work.d[106]*work.L[248]-1*work.d[458]*1-work.L[249]*work.d[457]*work.L[249];
residual += temp*temp;
temp = work.KKT[933]-work.L[250]*work.d[107]*work.L[250]-1*work.d[459]*1-work.L[251]*work.d[457]*work.L[251]-work.L[252]*work.d[458]*work.L[252];
residual += temp*temp;
temp = work.KKT[936]-work.L[253]*work.d[108]*work.L[253]-1*work.d[460]*1;
residual += temp*temp;
temp = work.KKT[940]-work.L[255]*work.d[109]*work.L[255]-1*work.d[462]*1-work.L[256]*work.d[461]*work.L[256];
residual += temp*temp;
temp = work.KKT[943]-work.L[257]*work.d[110]*work.L[257]-1*work.d[463]*1-work.L[258]*work.d[461]*work.L[258]-work.L[259]*work.d[462]*work.L[259];
residual += temp*temp;
temp = work.KKT[946]-work.L[260]*work.d[111]*work.L[260]-1*work.d[464]*1;
residual += temp*temp;
temp = work.KKT[950]-work.L[262]*work.d[112]*work.L[262]-1*work.d[466]*1-work.L[263]*work.d[465]*work.L[263];
residual += temp*temp;
temp = work.KKT[953]-work.L[264]*work.d[113]*work.L[264]-1*work.d[467]*1-work.L[265]*work.d[465]*work.L[265]-work.L[266]*work.d[466]*work.L[266];
residual += temp*temp;
temp = work.KKT[956]-work.L[267]*work.d[114]*work.L[267]-1*work.d[468]*1;
residual += temp*temp;
temp = work.KKT[960]-work.L[269]*work.d[115]*work.L[269]-1*work.d[470]*1-work.L[270]*work.d[469]*work.L[270];
residual += temp*temp;
temp = work.KKT[963]-work.L[271]*work.d[116]*work.L[271]-1*work.d[471]*1-work.L[272]*work.d[469]*work.L[272]-work.L[273]*work.d[470]*work.L[273];
residual += temp*temp;
temp = work.KKT[966]-work.L[274]*work.d[117]*work.L[274]-1*work.d[472]*1;
residual += temp*temp;
temp = work.KKT[970]-work.L[276]*work.d[118]*work.L[276]-1*work.d[474]*1-work.L[277]*work.d[473]*work.L[277];
residual += temp*temp;
temp = work.KKT[973]-work.L[278]*work.d[119]*work.L[278]-1*work.d[475]*1-work.L[279]*work.d[473]*work.L[279]-work.L[280]*work.d[474]*work.L[280];
residual += temp*temp;
temp = work.KKT[976]-work.L[281]*work.d[120]*work.L[281]-1*work.d[476]*1;
residual += temp*temp;
temp = work.KKT[980]-work.L[283]*work.d[121]*work.L[283]-1*work.d[478]*1-work.L[284]*work.d[477]*work.L[284];
residual += temp*temp;
temp = work.KKT[983]-work.L[285]*work.d[122]*work.L[285]-1*work.d[479]*1-work.L[286]*work.d[477]*work.L[286]-work.L[287]*work.d[478]*work.L[287];
residual += temp*temp;
temp = work.KKT[986]-work.L[288]*work.d[123]*work.L[288]-1*work.d[480]*1;
residual += temp*temp;
temp = work.KKT[990]-work.L[290]*work.d[124]*work.L[290]-1*work.d[482]*1-work.L[291]*work.d[481]*work.L[291];
residual += temp*temp;
temp = work.KKT[993]-work.L[292]*work.d[125]*work.L[292]-1*work.d[483]*1-work.L[293]*work.d[481]*work.L[293]-work.L[294]*work.d[482]*work.L[294];
residual += temp*temp;
temp = work.KKT[996]-work.L[295]*work.d[126]*work.L[295]-1*work.d[484]*1;
residual += temp*temp;
temp = work.KKT[1000]-work.L[297]*work.d[127]*work.L[297]-1*work.d[486]*1-work.L[298]*work.d[485]*work.L[298];
residual += temp*temp;
temp = work.KKT[1003]-work.L[299]*work.d[128]*work.L[299]-1*work.d[487]*1-work.L[300]*work.d[485]*work.L[300]-work.L[301]*work.d[486]*work.L[301];
residual += temp*temp;
temp = work.KKT[1006]-work.L[302]*work.d[129]*work.L[302]-1*work.d[488]*1;
residual += temp*temp;
temp = work.KKT[1010]-work.L[304]*work.d[130]*work.L[304]-1*work.d[490]*1-work.L[305]*work.d[489]*work.L[305];
residual += temp*temp;
temp = work.KKT[1013]-work.L[306]*work.d[131]*work.L[306]-1*work.d[491]*1-work.L[307]*work.d[489]*work.L[307]-work.L[308]*work.d[490]*work.L[308];
residual += temp*temp;
temp = work.KKT[1016]-work.L[309]*work.d[132]*work.L[309]-1*work.d[492]*1;
residual += temp*temp;
temp = work.KKT[1020]-work.L[311]*work.d[133]*work.L[311]-1*work.d[494]*1-work.L[312]*work.d[493]*work.L[312];
residual += temp*temp;
temp = work.KKT[1023]-work.L[313]*work.d[134]*work.L[313]-1*work.d[495]*1-work.L[314]*work.d[493]*work.L[314]-work.L[315]*work.d[494]*work.L[315];
residual += temp*temp;
temp = work.KKT[1026]-work.L[316]*work.d[135]*work.L[316]-1*work.d[496]*1;
residual += temp*temp;
temp = work.KKT[1030]-work.L[318]*work.d[136]*work.L[318]-1*work.d[498]*1-work.L[319]*work.d[497]*work.L[319];
residual += temp*temp;
temp = work.KKT[1033]-work.L[320]*work.d[137]*work.L[320]-1*work.d[499]*1-work.L[321]*work.d[497]*work.L[321]-work.L[322]*work.d[498]*work.L[322];
residual += temp*temp;
temp = work.KKT[1036]-work.L[323]*work.d[138]*work.L[323]-1*work.d[500]*1;
residual += temp*temp;
temp = work.KKT[1040]-work.L[325]*work.d[139]*work.L[325]-1*work.d[502]*1-work.L[326]*work.d[501]*work.L[326];
residual += temp*temp;
temp = work.KKT[1043]-work.L[327]*work.d[140]*work.L[327]-1*work.d[503]*1-work.L[328]*work.d[501]*work.L[328]-work.L[329]*work.d[502]*work.L[329];
residual += temp*temp;
temp = work.KKT[1046]-work.L[330]*work.d[141]*work.L[330]-1*work.d[504]*1;
residual += temp*temp;
temp = work.KKT[1050]-work.L[332]*work.d[142]*work.L[332]-1*work.d[506]*1-work.L[333]*work.d[505]*work.L[333];
residual += temp*temp;
temp = work.KKT[1053]-work.L[334]*work.d[143]*work.L[334]-1*work.d[507]*1-work.L[335]*work.d[505]*work.L[335]-work.L[336]*work.d[506]*work.L[336];
residual += temp*temp;
temp = work.KKT[1056]-work.L[337]*work.d[144]*work.L[337]-1*work.d[508]*1;
residual += temp*temp;
temp = work.KKT[1060]-work.L[339]*work.d[145]*work.L[339]-1*work.d[510]*1-work.L[340]*work.d[509]*work.L[340];
residual += temp*temp;
temp = work.KKT[1063]-work.L[341]*work.d[146]*work.L[341]-1*work.d[511]*1-work.L[342]*work.d[509]*work.L[342]-work.L[343]*work.d[510]*work.L[343];
residual += temp*temp;
temp = work.KKT[1066]-work.L[344]*work.d[147]*work.L[344]-1*work.d[512]*1;
residual += temp*temp;
temp = work.KKT[1070]-work.L[346]*work.d[148]*work.L[346]-1*work.d[514]*1-work.L[347]*work.d[513]*work.L[347];
residual += temp*temp;
temp = work.KKT[1073]-work.L[348]*work.d[149]*work.L[348]-1*work.d[515]*1-work.L[349]*work.d[513]*work.L[349]-work.L[350]*work.d[514]*work.L[350];
residual += temp*temp;
temp = work.KKT[1076]-work.L[351]*work.d[150]*work.L[351]-1*work.d[516]*1;
residual += temp*temp;
temp = work.KKT[1080]-work.L[353]*work.d[151]*work.L[353]-1*work.d[518]*1-work.L[354]*work.d[517]*work.L[354];
residual += temp*temp;
temp = work.KKT[1083]-work.L[355]*work.d[152]*work.L[355]-1*work.d[519]*1-work.L[356]*work.d[517]*work.L[356]-work.L[357]*work.d[518]*work.L[357];
residual += temp*temp;
temp = work.KKT[1086]-work.L[358]*work.d[153]*work.L[358]-1*work.d[520]*1;
residual += temp*temp;
temp = work.KKT[1090]-work.L[360]*work.d[154]*work.L[360]-1*work.d[522]*1-work.L[361]*work.d[521]*work.L[361];
residual += temp*temp;
temp = work.KKT[1093]-work.L[362]*work.d[155]*work.L[362]-1*work.d[523]*1-work.L[363]*work.d[521]*work.L[363]-work.L[364]*work.d[522]*work.L[364];
residual += temp*temp;
temp = work.KKT[1096]-work.L[365]*work.d[156]*work.L[365]-1*work.d[524]*1;
residual += temp*temp;
temp = work.KKT[1100]-work.L[367]*work.d[157]*work.L[367]-1*work.d[526]*1-work.L[368]*work.d[525]*work.L[368];
residual += temp*temp;
temp = work.KKT[1102]-work.L[369]*work.d[158]*work.L[369]-1*work.d[527]*1-work.L[370]*work.d[525]*work.L[370]-work.L[371]*work.d[526]*work.L[371];
residual += temp*temp;
temp = work.KKT[1104]-work.L[372]*work.d[159]*work.L[372]-1*work.d[528]*1;
residual += temp*temp;
temp = work.KKT[1108]-work.L[374]*work.d[160]*work.L[374]-1*work.d[530]*1-work.L[375]*work.d[529]*work.L[375];
residual += temp*temp;
temp = work.KKT[1110]-work.L[376]*work.d[161]*work.L[376]-1*work.d[531]*1-work.L[377]*work.d[529]*work.L[377]-work.L[378]*work.d[530]*work.L[378];
residual += temp*temp;
temp = work.KKT[1112]-work.L[379]*work.d[162]*work.L[379]-1*work.d[532]*1;
residual += temp*temp;
temp = work.KKT[1116]-work.L[381]*work.d[163]*work.L[381]-1*work.d[534]*1-work.L[382]*work.d[533]*work.L[382];
residual += temp*temp;
temp = work.KKT[1118]-work.L[383]*work.d[164]*work.L[383]-1*work.d[535]*1-work.L[384]*work.d[533]*work.L[384]-work.L[385]*work.d[534]*work.L[385];
residual += temp*temp;
temp = work.KKT[1120]-work.L[386]*work.d[165]*work.L[386]-1*work.d[536]*1;
residual += temp*temp;
temp = work.KKT[1124]-work.L[388]*work.d[166]*work.L[388]-1*work.d[538]*1-work.L[389]*work.d[537]*work.L[389];
residual += temp*temp;
temp = work.KKT[1126]-work.L[390]*work.d[167]*work.L[390]-1*work.d[539]*1-work.L[391]*work.d[537]*work.L[391]-work.L[392]*work.d[538]*work.L[392];
residual += temp*temp;
temp = work.KKT[1128]-work.L[393]*work.d[168]*work.L[393]-1*work.d[540]*1;
residual += temp*temp;
temp = work.KKT[1132]-work.L[395]*work.d[169]*work.L[395]-1*work.d[542]*1-work.L[396]*work.d[541]*work.L[396];
residual += temp*temp;
temp = work.KKT[1134]-work.L[397]*work.d[170]*work.L[397]-1*work.d[543]*1-work.L[398]*work.d[541]*work.L[398]-work.L[399]*work.d[542]*work.L[399];
residual += temp*temp;
temp = work.KKT[1136]-work.L[400]*work.d[171]*work.L[400]-1*work.d[544]*1;
residual += temp*temp;
temp = work.KKT[1140]-work.L[402]*work.d[172]*work.L[402]-1*work.d[546]*1-work.L[403]*work.d[545]*work.L[403];
residual += temp*temp;
temp = work.KKT[1142]-work.L[404]*work.d[173]*work.L[404]-1*work.d[547]*1-work.L[405]*work.d[545]*work.L[405]-work.L[406]*work.d[546]*work.L[406];
residual += temp*temp;
temp = work.KKT[1144]-work.L[407]*work.d[174]*work.L[407]-1*work.d[548]*1;
residual += temp*temp;
temp = work.KKT[1148]-work.L[409]*work.d[175]*work.L[409]-1*work.d[550]*1-work.L[410]*work.d[549]*work.L[410];
residual += temp*temp;
temp = work.KKT[1150]-work.L[411]*work.d[176]*work.L[411]-1*work.d[551]*1-work.L[412]*work.d[549]*work.L[412]-work.L[413]*work.d[550]*work.L[413];
residual += temp*temp;
temp = work.KKT[1152]-work.L[414]*work.d[177]*work.L[414]-1*work.d[552]*1;
residual += temp*temp;
temp = work.KKT[1156]-work.L[416]*work.d[178]*work.L[416]-1*work.d[554]*1-work.L[417]*work.d[553]*work.L[417];
residual += temp*temp;
temp = work.KKT[1158]-work.L[418]*work.d[179]*work.L[418]-1*work.d[555]*1-work.L[419]*work.d[553]*work.L[419]-work.L[420]*work.d[554]*work.L[420];
residual += temp*temp;
temp = work.KKT[1160]-work.L[421]*work.d[180]*work.L[421]-1*work.d[556]*1;
residual += temp*temp;
temp = work.KKT[1164]-work.L[423]*work.d[181]*work.L[423]-1*work.d[558]*1-work.L[424]*work.d[557]*work.L[424];
residual += temp*temp;
temp = work.KKT[1166]-work.L[425]*work.d[182]*work.L[425]-1*work.d[559]*1-work.L[426]*work.d[557]*work.L[426]-work.L[427]*work.d[558]*work.L[427];
residual += temp*temp;
temp = work.KKT[1168]-work.L[428]*work.d[183]*work.L[428]-1*work.d[560]*1;
residual += temp*temp;
temp = work.KKT[1172]-work.L[430]*work.d[184]*work.L[430]-1*work.d[562]*1-work.L[431]*work.d[561]*work.L[431];
residual += temp*temp;
temp = work.KKT[1174]-work.L[432]*work.d[185]*work.L[432]-1*work.d[563]*1-work.L[433]*work.d[561]*work.L[433]-work.L[434]*work.d[562]*work.L[434];
residual += temp*temp;
temp = work.KKT[1176]-work.L[435]*work.d[186]*work.L[435]-1*work.d[564]*1;
residual += temp*temp;
temp = work.KKT[1180]-work.L[437]*work.d[187]*work.L[437]-1*work.d[566]*1-work.L[438]*work.d[565]*work.L[438];
residual += temp*temp;
temp = work.KKT[1182]-work.L[439]*work.d[188]*work.L[439]-1*work.d[567]*1-work.L[440]*work.d[565]*work.L[440]-work.L[441]*work.d[566]*work.L[441];
residual += temp*temp;
temp = work.KKT[1184]-work.L[442]*work.d[189]*work.L[442]-1*work.d[568]*1;
residual += temp*temp;
temp = work.KKT[1188]-work.L[444]*work.d[190]*work.L[444]-1*work.d[570]*1-work.L[445]*work.d[569]*work.L[445];
residual += temp*temp;
temp = work.KKT[1190]-work.L[446]*work.d[191]*work.L[446]-1*work.d[571]*1-work.L[447]*work.d[569]*work.L[447]-work.L[448]*work.d[570]*work.L[448];
residual += temp*temp;
temp = work.KKT[1192]-work.L[449]*work.d[192]*work.L[449]-1*work.d[572]*1;
residual += temp*temp;
temp = work.KKT[1196]-work.L[451]*work.d[193]*work.L[451]-1*work.d[574]*1-work.L[452]*work.d[573]*work.L[452];
residual += temp*temp;
temp = work.KKT[1198]-work.L[453]*work.d[194]*work.L[453]-1*work.d[575]*1-work.L[454]*work.d[573]*work.L[454]-work.L[455]*work.d[574]*work.L[455];
residual += temp*temp;
temp = work.KKT[1200]-work.L[456]*work.d[195]*work.L[456]-1*work.d[576]*1;
residual += temp*temp;
temp = work.KKT[1204]-work.L[458]*work.d[196]*work.L[458]-1*work.d[578]*1-work.L[459]*work.d[577]*work.L[459];
residual += temp*temp;
temp = work.KKT[1206]-work.L[460]*work.d[197]*work.L[460]-1*work.d[579]*1-work.L[461]*work.d[577]*work.L[461]-work.L[462]*work.d[578]*work.L[462];
residual += temp*temp;
temp = work.KKT[1208]-work.L[463]*work.d[198]*work.L[463]-1*work.d[580]*1;
residual += temp*temp;
temp = work.KKT[1212]-work.L[465]*work.d[199]*work.L[465]-1*work.d[582]*1-work.L[466]*work.d[581]*work.L[466];
residual += temp*temp;
temp = work.KKT[1214]-work.L[467]*work.d[200]*work.L[467]-1*work.d[583]*1-work.L[468]*work.d[581]*work.L[468]-work.L[469]*work.d[582]*work.L[469];
residual += temp*temp;
temp = work.KKT[1216]-work.L[470]*work.d[201]*work.L[470]-1*work.d[584]*1;
residual += temp*temp;
temp = work.KKT[1220]-work.L[472]*work.d[202]*work.L[472]-1*work.d[586]*1-work.L[473]*work.d[585]*work.L[473];
residual += temp*temp;
temp = work.KKT[1222]-work.L[474]*work.d[203]*work.L[474]-1*work.d[587]*1-work.L[475]*work.d[585]*work.L[475]-work.L[476]*work.d[586]*work.L[476];
residual += temp*temp;
temp = work.KKT[1224]-work.L[477]*work.d[204]*work.L[477]-1*work.d[588]*1;
residual += temp*temp;
temp = work.KKT[1228]-work.L[479]*work.d[205]*work.L[479]-1*work.d[590]*1-work.L[480]*work.d[589]*work.L[480];
residual += temp*temp;
temp = work.KKT[1230]-work.L[481]*work.d[206]*work.L[481]-1*work.d[591]*1-work.L[482]*work.d[589]*work.L[482]-work.L[483]*work.d[590]*work.L[483];
residual += temp*temp;
temp = work.KKT[1232]-work.L[484]*work.d[207]*work.L[484]-1*work.d[592]*1;
residual += temp*temp;
temp = work.KKT[1236]-work.L[486]*work.d[208]*work.L[486]-1*work.d[594]*1-work.L[487]*work.d[593]*work.L[487];
residual += temp*temp;
temp = work.KKT[1238]-work.L[488]*work.d[209]*work.L[488]-1*work.d[595]*1-work.L[489]*work.d[593]*work.L[489]-work.L[490]*work.d[594]*work.L[490];
residual += temp*temp;
temp = work.KKT[1240]-work.L[491]*work.d[210]*work.L[491]-1*work.d[596]*1;
residual += temp*temp;
temp = work.KKT[1244]-work.L[493]*work.d[211]*work.L[493]-1*work.d[598]*1-work.L[494]*work.d[597]*work.L[494];
residual += temp*temp;
temp = work.KKT[1246]-work.L[495]*work.d[212]*work.L[495]-1*work.d[599]*1-work.L[496]*work.d[597]*work.L[496]-work.L[497]*work.d[598]*work.L[497];
residual += temp*temp;
temp = work.KKT[1248]-work.L[498]*work.d[213]*work.L[498]-1*work.d[600]*1;
residual += temp*temp;
temp = work.KKT[1252]-work.L[500]*work.d[214]*work.L[500]-1*work.d[602]*1-work.L[501]*work.d[601]*work.L[501];
residual += temp*temp;
temp = work.KKT[1254]-work.L[502]*work.d[215]*work.L[502]-1*work.d[603]*1-work.L[503]*work.d[601]*work.L[503]-work.L[504]*work.d[602]*work.L[504];
residual += temp*temp;
temp = work.KKT[1256]-work.L[505]*work.d[216]*work.L[505]-1*work.d[604]*1;
residual += temp*temp;
temp = work.KKT[1260]-work.L[507]*work.d[217]*work.L[507]-1*work.d[606]*1-work.L[508]*work.d[605]*work.L[508];
residual += temp*temp;
temp = work.KKT[1262]-work.L[509]*work.d[218]*work.L[509]-1*work.d[607]*1-work.L[510]*work.d[605]*work.L[510]-work.L[511]*work.d[606]*work.L[511];
residual += temp*temp;
temp = work.KKT[1264]-work.L[512]*work.d[219]*work.L[512]-1*work.d[608]*1;
residual += temp*temp;
temp = work.KKT[1268]-work.L[514]*work.d[220]*work.L[514]-1*work.d[610]*1-work.L[515]*work.d[609]*work.L[515];
residual += temp*temp;
temp = work.KKT[1270]-work.L[516]*work.d[221]*work.L[516]-1*work.d[611]*1-work.L[517]*work.d[609]*work.L[517]-work.L[518]*work.d[610]*work.L[518];
residual += temp*temp;
temp = work.KKT[1272]-work.L[519]*work.d[222]*work.L[519]-1*work.d[612]*1;
residual += temp*temp;
temp = work.KKT[1276]-work.L[521]*work.d[223]*work.L[521]-1*work.d[614]*1-work.L[522]*work.d[613]*work.L[522];
residual += temp*temp;
temp = work.KKT[1278]-work.L[523]*work.d[224]*work.L[523]-1*work.d[615]*1-work.L[524]*work.d[613]*work.L[524]-work.L[525]*work.d[614]*work.L[525];
residual += temp*temp;
temp = work.KKT[1280]-work.L[526]*work.d[225]*work.L[526]-1*work.d[616]*1;
residual += temp*temp;
temp = work.KKT[1284]-work.L[528]*work.d[226]*work.L[528]-1*work.d[618]*1-work.L[529]*work.d[617]*work.L[529];
residual += temp*temp;
temp = work.KKT[1286]-work.L[530]*work.d[227]*work.L[530]-1*work.d[619]*1-work.L[531]*work.d[617]*work.L[531]-work.L[532]*work.d[618]*work.L[532];
residual += temp*temp;
temp = work.KKT[1288]-work.L[533]*work.d[228]*work.L[533]-1*work.d[620]*1;
residual += temp*temp;
temp = work.KKT[1292]-work.L[535]*work.d[229]*work.L[535]-1*work.d[622]*1-work.L[536]*work.d[621]*work.L[536];
residual += temp*temp;
temp = work.KKT[1294]-work.L[537]*work.d[230]*work.L[537]-1*work.d[623]*1-work.L[538]*work.d[621]*work.L[538]-work.L[539]*work.d[622]*work.L[539];
residual += temp*temp;
temp = work.KKT[1296]-work.L[540]*work.d[231]*work.L[540]-1*work.d[624]*1;
residual += temp*temp;
temp = work.KKT[1300]-work.L[542]*work.d[232]*work.L[542]-1*work.d[626]*1-work.L[543]*work.d[625]*work.L[543];
residual += temp*temp;
temp = work.KKT[1302]-work.L[544]*work.d[233]*work.L[544]-1*work.d[627]*1-work.L[545]*work.d[625]*work.L[545]-work.L[546]*work.d[626]*work.L[546];
residual += temp*temp;
temp = work.KKT[1306]-work.L[549]*work.d[234]*work.L[549]-1*work.d[629]*1;
residual += temp*temp;
temp = work.KKT[1310]-work.L[551]*work.d[235]*work.L[551]-1*work.d[631]*1-work.L[552]*work.d[630]*work.L[552];
residual += temp*temp;
temp = work.KKT[1312]-work.L[553]*work.d[236]*work.L[553]-1*work.d[632]*1-work.L[554]*work.d[630]*work.L[554]-work.L[555]*work.d[631]*work.L[555];
residual += temp*temp;
temp = work.KKT[1314]-work.L[556]*work.d[237]*work.L[556]-1*work.d[633]*1;
residual += temp*temp;
temp = work.KKT[1318]-work.L[558]*work.d[238]*work.L[558]-1*work.d[635]*1-work.L[559]*work.d[634]*work.L[559];
residual += temp*temp;
temp = work.KKT[1320]-work.L[560]*work.d[239]*work.L[560]-1*work.d[636]*1-work.L[561]*work.d[634]*work.L[561]-work.L[562]*work.d[635]*work.L[562];
residual += temp*temp;
temp = work.KKT[1322]-work.L[563]*work.d[240]*work.L[563]-1*work.d[637]*1;
residual += temp*temp;
temp = work.KKT[1326]-work.L[565]*work.d[241]*work.L[565]-1*work.d[639]*1-work.L[566]*work.d[638]*work.L[566];
residual += temp*temp;
temp = work.KKT[1328]-work.L[567]*work.d[242]*work.L[567]-1*work.d[640]*1-work.L[568]*work.d[638]*work.L[568]-work.L[569]*work.d[639]*work.L[569];
residual += temp*temp;
temp = work.KKT[1330]-work.L[570]*work.d[243]*work.L[570]-1*work.d[641]*1;
residual += temp*temp;
temp = work.KKT[1334]-work.L[572]*work.d[244]*work.L[572]-1*work.d[643]*1-work.L[573]*work.d[642]*work.L[573];
residual += temp*temp;
temp = work.KKT[1336]-work.L[574]*work.d[245]*work.L[574]-1*work.d[644]*1-work.L[575]*work.d[642]*work.L[575]-work.L[576]*work.d[643]*work.L[576];
residual += temp*temp;
temp = work.KKT[1338]-work.L[577]*work.d[246]*work.L[577]-1*work.d[645]*1;
residual += temp*temp;
temp = work.KKT[1342]-work.L[579]*work.d[247]*work.L[579]-1*work.d[647]*1-work.L[580]*work.d[646]*work.L[580];
residual += temp*temp;
temp = work.KKT[1344]-work.L[581]*work.d[248]*work.L[581]-1*work.d[648]*1-work.L[582]*work.d[646]*work.L[582]-work.L[583]*work.d[647]*work.L[583];
residual += temp*temp;
temp = work.KKT[1346]-work.L[584]*work.d[249]*work.L[584]-1*work.d[649]*1;
residual += temp*temp;
temp = work.KKT[1350]-work.L[586]*work.d[250]*work.L[586]-1*work.d[651]*1-work.L[587]*work.d[650]*work.L[587];
residual += temp*temp;
temp = work.KKT[1352]-work.L[588]*work.d[251]*work.L[588]-1*work.d[652]*1-work.L[589]*work.d[650]*work.L[589]-work.L[590]*work.d[651]*work.L[590];
residual += temp*temp;
temp = work.KKT[1354]-work.L[591]*work.d[252]*work.L[591]-1*work.d[653]*1;
residual += temp*temp;
temp = work.KKT[1358]-work.L[593]*work.d[253]*work.L[593]-1*work.d[655]*1-work.L[594]*work.d[654]*work.L[594];
residual += temp*temp;
temp = work.KKT[1360]-work.L[595]*work.d[254]*work.L[595]-1*work.d[656]*1-work.L[596]*work.d[654]*work.L[596]-work.L[597]*work.d[655]*work.L[597];
residual += temp*temp;
temp = work.KKT[1362]-work.L[598]*work.d[255]*work.L[598]-1*work.d[657]*1;
residual += temp*temp;
temp = work.KKT[1366]-work.L[600]*work.d[256]*work.L[600]-1*work.d[659]*1-work.L[601]*work.d[658]*work.L[601];
residual += temp*temp;
temp = work.KKT[1368]-work.L[602]*work.d[257]*work.L[602]-1*work.d[660]*1-work.L[603]*work.d[658]*work.L[603]-work.L[604]*work.d[659]*work.L[604];
residual += temp*temp;
temp = work.KKT[1370]-work.L[605]*work.d[258]*work.L[605]-1*work.d[661]*1;
residual += temp*temp;
temp = work.KKT[1374]-work.L[607]*work.d[259]*work.L[607]-1*work.d[663]*1-work.L[608]*work.d[662]*work.L[608];
residual += temp*temp;
temp = work.KKT[1376]-work.L[609]*work.d[260]*work.L[609]-1*work.d[664]*1-work.L[610]*work.d[662]*work.L[610]-work.L[611]*work.d[663]*work.L[611];
residual += temp*temp;
temp = work.KKT[1378]-work.L[612]*work.d[261]*work.L[612]-1*work.d[665]*1;
residual += temp*temp;
temp = work.KKT[1382]-work.L[614]*work.d[262]*work.L[614]-1*work.d[667]*1-work.L[615]*work.d[666]*work.L[615];
residual += temp*temp;
temp = work.KKT[1384]-work.L[616]*work.d[263]*work.L[616]-1*work.d[668]*1-work.L[617]*work.d[666]*work.L[617]-work.L[618]*work.d[667]*work.L[618];
residual += temp*temp;
temp = work.KKT[1386]-work.L[619]*work.d[264]*work.L[619]-1*work.d[669]*1;
residual += temp*temp;
temp = work.KKT[1390]-work.L[621]*work.d[265]*work.L[621]-1*work.d[671]*1-work.L[622]*work.d[670]*work.L[622];
residual += temp*temp;
temp = work.KKT[1392]-work.L[623]*work.d[266]*work.L[623]-1*work.d[672]*1-work.L[624]*work.d[670]*work.L[624]-work.L[625]*work.d[671]*work.L[625];
residual += temp*temp;
temp = work.KKT[1394]-work.L[626]*work.d[267]*work.L[626]-1*work.d[673]*1;
residual += temp*temp;
temp = work.KKT[1398]-work.L[628]*work.d[268]*work.L[628]-1*work.d[675]*1-work.L[629]*work.d[674]*work.L[629];
residual += temp*temp;
temp = work.KKT[1400]-work.L[630]*work.d[269]*work.L[630]-1*work.d[676]*1-work.L[631]*work.d[674]*work.L[631]-work.L[632]*work.d[675]*work.L[632];
residual += temp*temp;
temp = work.KKT[1402]-work.L[633]*work.d[270]*work.L[633]-1*work.d[677]*1;
residual += temp*temp;
temp = work.KKT[1406]-work.L[635]*work.d[271]*work.L[635]-1*work.d[679]*1-work.L[636]*work.d[678]*work.L[636];
residual += temp*temp;
temp = work.KKT[1408]-work.L[637]*work.d[272]*work.L[637]-1*work.d[680]*1-work.L[638]*work.d[678]*work.L[638]-work.L[639]*work.d[679]*work.L[639];
residual += temp*temp;
temp = work.KKT[1410]-work.L[640]*work.d[273]*work.L[640]-1*work.d[681]*1;
residual += temp*temp;
temp = work.KKT[1414]-work.L[642]*work.d[274]*work.L[642]-1*work.d[683]*1-work.L[643]*work.d[682]*work.L[643];
residual += temp*temp;
temp = work.KKT[1416]-work.L[644]*work.d[275]*work.L[644]-1*work.d[684]*1-work.L[645]*work.d[682]*work.L[645]-work.L[646]*work.d[683]*work.L[646];
residual += temp*temp;
temp = work.KKT[1418]-work.L[647]*work.d[276]*work.L[647]-1*work.d[685]*1;
residual += temp*temp;
temp = work.KKT[1422]-work.L[649]*work.d[277]*work.L[649]-1*work.d[687]*1-work.L[650]*work.d[686]*work.L[650];
residual += temp*temp;
temp = work.KKT[1424]-work.L[651]*work.d[278]*work.L[651]-1*work.d[688]*1-work.L[652]*work.d[686]*work.L[652]-work.L[653]*work.d[687]*work.L[653];
residual += temp*temp;
temp = work.KKT[1426]-work.L[654]*work.d[279]*work.L[654]-1*work.d[689]*1;
residual += temp*temp;
temp = work.KKT[1430]-work.L[656]*work.d[280]*work.L[656]-1*work.d[691]*1-work.L[657]*work.d[690]*work.L[657];
residual += temp*temp;
temp = work.KKT[1432]-work.L[658]*work.d[281]*work.L[658]-1*work.d[692]*1-work.L[659]*work.d[690]*work.L[659]-work.L[660]*work.d[691]*work.L[660];
residual += temp*temp;
temp = work.KKT[1434]-work.L[661]*work.d[282]*work.L[661]-1*work.d[693]*1;
residual += temp*temp;
temp = work.KKT[1438]-work.L[663]*work.d[283]*work.L[663]-1*work.d[695]*1-work.L[664]*work.d[694]*work.L[664];
residual += temp*temp;
temp = work.KKT[1440]-work.L[665]*work.d[284]*work.L[665]-1*work.d[696]*1-work.L[666]*work.d[694]*work.L[666]-work.L[667]*work.d[695]*work.L[667];
residual += temp*temp;
temp = work.KKT[1442]-work.L[668]*work.d[285]*work.L[668]-1*work.d[697]*1;
residual += temp*temp;
temp = work.KKT[1446]-work.L[670]*work.d[286]*work.L[670]-1*work.d[699]*1-work.L[671]*work.d[698]*work.L[671];
residual += temp*temp;
temp = work.KKT[1448]-work.L[672]*work.d[287]*work.L[672]-1*work.d[700]*1-work.L[673]*work.d[698]*work.L[673]-work.L[674]*work.d[699]*work.L[674];
residual += temp*temp;
temp = work.KKT[1450]-work.L[675]*work.d[288]*work.L[675]-1*work.d[701]*1;
residual += temp*temp;
temp = work.KKT[1454]-work.L[677]*work.d[289]*work.L[677]-1*work.d[703]*1-work.L[678]*work.d[702]*work.L[678];
residual += temp*temp;
temp = work.KKT[1456]-work.L[679]*work.d[290]*work.L[679]-1*work.d[704]*1-work.L[680]*work.d[702]*work.L[680]-work.L[681]*work.d[703]*work.L[681];
residual += temp*temp;
temp = work.KKT[1458]-work.L[682]*work.d[291]*work.L[682]-1*work.d[705]*1;
residual += temp*temp;
temp = work.KKT[1462]-work.L[684]*work.d[292]*work.L[684]-1*work.d[707]*1-work.L[685]*work.d[706]*work.L[685];
residual += temp*temp;
temp = work.KKT[1464]-work.L[686]*work.d[293]*work.L[686]-1*work.d[708]*1-work.L[687]*work.d[706]*work.L[687]-work.L[688]*work.d[707]*work.L[688];
residual += temp*temp;
temp = work.KKT[1466]-work.L[689]*work.d[294]*work.L[689]-1*work.d[709]*1;
residual += temp*temp;
temp = work.KKT[1470]-work.L[691]*work.d[295]*work.L[691]-1*work.d[711]*1-work.L[692]*work.d[710]*work.L[692];
residual += temp*temp;
temp = work.KKT[1472]-work.L[693]*work.d[296]*work.L[693]-1*work.d[712]*1-work.L[694]*work.d[710]*work.L[694]-work.L[695]*work.d[711]*work.L[695];
residual += temp*temp;
temp = work.KKT[1474]-work.L[696]*work.d[297]*work.L[696]-1*work.d[713]*1;
residual += temp*temp;
temp = work.KKT[1478]-work.L[698]*work.d[298]*work.L[698]-1*work.d[715]*1-work.L[699]*work.d[714]*work.L[699];
residual += temp*temp;
temp = work.KKT[1480]-work.L[700]*work.d[299]*work.L[700]-1*work.d[716]*1-work.L[701]*work.d[714]*work.L[701]-work.L[702]*work.d[715]*work.L[702];
residual += temp*temp;
temp = work.KKT[1482]-work.L[703]*work.d[300]*work.L[703]-1*work.d[717]*1;
residual += temp*temp;
temp = work.KKT[1486]-work.L[705]*work.d[301]*work.L[705]-1*work.d[719]*1-work.L[706]*work.d[718]*work.L[706];
residual += temp*temp;
temp = work.KKT[1488]-work.L[707]*work.d[302]*work.L[707]-1*work.d[720]*1-work.L[708]*work.d[718]*work.L[708]-work.L[709]*work.d[719]*work.L[709];
residual += temp*temp;
temp = work.KKT[1490]-work.L[710]*work.d[303]*work.L[710]-1*work.d[721]*1;
residual += temp*temp;
temp = work.KKT[1494]-work.L[712]*work.d[304]*work.L[712]-1*work.d[723]*1-work.L[713]*work.d[722]*work.L[713];
residual += temp*temp;
temp = work.KKT[1496]-work.L[714]*work.d[305]*work.L[714]-1*work.d[724]*1-work.L[715]*work.d[722]*work.L[715]-work.L[716]*work.d[723]*work.L[716];
residual += temp*temp;
temp = work.KKT[1498]-work.L[717]*work.d[306]*work.L[717]-1*work.d[725]*1;
residual += temp*temp;
temp = work.KKT[1502]-work.L[719]*work.d[307]*work.L[719]-1*work.d[727]*1-work.L[720]*work.d[726]*work.L[720];
residual += temp*temp;
temp = work.KKT[1504]-work.L[721]*work.d[308]*work.L[721]-1*work.d[728]*1-work.L[722]*work.d[726]*work.L[722]-work.L[723]*work.d[727]*work.L[723];
residual += temp*temp;
temp = work.KKT[1506]-work.L[724]*work.d[309]*work.L[724]-1*work.d[729]*1;
residual += temp*temp;
temp = work.KKT[1510]-work.L[726]*work.d[310]*work.L[726]-1*work.d[731]*1-work.L[727]*work.d[730]*work.L[727];
residual += temp*temp;
temp = work.KKT[1512]-work.L[728]*work.d[311]*work.L[728]-1*work.d[732]*1-work.L[729]*work.d[730]*work.L[729]-work.L[730]*work.d[731]*work.L[730];
residual += temp*temp;
temp = work.KKT[631]-1*work.d[316]*work.L[2];
residual += temp*temp;
temp = work.KKT[632]-work.L[4]*work.d[317]*1;
residual += temp*temp;
temp = work.KKT[635]-1*work.d[318]*work.L[737];
residual += temp*temp;
temp = work.KKT[633]-work.L[6]*work.d[317]*1;
residual += temp*temp;
temp = work.KKT[637]-1*work.d[319]*work.L[738]-work.L[7]*work.d[318]*work.L[737];
residual += temp*temp;
temp = work.KKT[639]-1*work.d[320]*work.L[9];
residual += temp*temp;
temp = work.KKT[640]-work.L[11]*work.d[321]*1;
residual += temp*temp;
temp = work.KKT[643]-1*work.d[322]*work.L[758];
residual += temp*temp;
temp = work.KKT[641]-work.L[13]*work.d[321]*1;
residual += temp*temp;
temp = work.KKT[645]-1*work.d[323]*work.L[759]-work.L[14]*work.d[322]*work.L[758];
residual += temp*temp;
temp = work.KKT[647]-1*work.d[324]*work.L[16];
residual += temp*temp;
temp = work.KKT[648]-work.L[18]*work.d[325]*1;
residual += temp*temp;
temp = work.KKT[651]-1*work.d[326]*work.L[820];
residual += temp*temp;
temp = work.KKT[649]-work.L[20]*work.d[325]*1;
residual += temp*temp;
temp = work.KKT[653]-1*work.d[327]*work.L[821]-work.L[21]*work.d[326]*work.L[820];
residual += temp*temp;
temp = work.KKT[655]-1*work.d[328]*work.L[23];
residual += temp*temp;
temp = work.KKT[656]-work.L[25]*work.d[329]*1;
residual += temp*temp;
temp = work.KKT[659]-1*work.d[330]*work.L[857];
residual += temp*temp;
temp = work.KKT[657]-work.L[27]*work.d[329]*1;
residual += temp*temp;
temp = work.KKT[661]-1*work.d[331]*work.L[858]-work.L[28]*work.d[330]*work.L[857];
residual += temp*temp;
temp = work.KKT[663]-1*work.d[332]*work.L[30];
residual += temp*temp;
temp = work.KKT[664]-work.L[32]*work.d[333]*1;
residual += temp*temp;
temp = work.KKT[667]-1*work.d[334]*work.L[891];
residual += temp*temp;
temp = work.KKT[665]-work.L[34]*work.d[333]*1;
residual += temp*temp;
temp = work.KKT[669]-1*work.d[335]*work.L[892]-work.L[35]*work.d[334]*work.L[891];
residual += temp*temp;
temp = work.KKT[671]-1*work.d[336]*work.L[37];
residual += temp*temp;
temp = work.KKT[672]-work.L[39]*work.d[337]*1;
residual += temp*temp;
temp = work.KKT[675]-1*work.d[338]*work.L[925];
residual += temp*temp;
temp = work.KKT[673]-work.L[41]*work.d[337]*1;
residual += temp*temp;
temp = work.KKT[677]-1*work.d[339]*work.L[926]-work.L[42]*work.d[338]*work.L[925];
residual += temp*temp;
temp = work.KKT[679]-1*work.d[340]*work.L[44];
residual += temp*temp;
temp = work.KKT[680]-work.L[46]*work.d[341]*1;
residual += temp*temp;
temp = work.KKT[683]-1*work.d[342]*work.L[959];
residual += temp*temp;
temp = work.KKT[681]-work.L[48]*work.d[341]*1;
residual += temp*temp;
temp = work.KKT[685]-1*work.d[343]*work.L[960]-work.L[49]*work.d[342]*work.L[959];
residual += temp*temp;
temp = work.KKT[687]-1*work.d[344]*work.L[51];
residual += temp*temp;
temp = work.KKT[688]-work.L[53]*work.d[345]*1;
residual += temp*temp;
temp = work.KKT[691]-1*work.d[346]*work.L[993];
residual += temp*temp;
temp = work.KKT[689]-work.L[55]*work.d[345]*1;
residual += temp*temp;
temp = work.KKT[693]-1*work.d[347]*work.L[994]-work.L[56]*work.d[346]*work.L[993];
residual += temp*temp;
temp = work.KKT[695]-1*work.d[348]*work.L[58];
residual += temp*temp;
temp = work.KKT[696]-work.L[60]*work.d[349]*1;
residual += temp*temp;
temp = work.KKT[699]-1*work.d[350]*work.L[1027];
residual += temp*temp;
temp = work.KKT[697]-work.L[62]*work.d[349]*1;
residual += temp*temp;
temp = work.KKT[701]-1*work.d[351]*work.L[1028]-work.L[63]*work.d[350]*work.L[1027];
residual += temp*temp;
temp = work.KKT[703]-1*work.d[352]*work.L[65];
residual += temp*temp;
temp = work.KKT[704]-work.L[67]*work.d[353]*1;
residual += temp*temp;
temp = work.KKT[707]-1*work.d[354]*work.L[1061];
residual += temp*temp;
temp = work.KKT[705]-work.L[69]*work.d[353]*1;
residual += temp*temp;
temp = work.KKT[709]-1*work.d[355]*work.L[1062]-work.L[70]*work.d[354]*work.L[1061];
residual += temp*temp;
temp = work.KKT[711]-1*work.d[356]*work.L[72];
residual += temp*temp;
temp = work.KKT[712]-work.L[74]*work.d[357]*1;
residual += temp*temp;
temp = work.KKT[715]-1*work.d[358]*work.L[1095];
residual += temp*temp;
temp = work.KKT[713]-work.L[76]*work.d[357]*1;
residual += temp*temp;
temp = work.KKT[717]-1*work.d[359]*work.L[1096]-work.L[77]*work.d[358]*work.L[1095];
residual += temp*temp;
temp = work.KKT[719]-1*work.d[360]*work.L[79];
residual += temp*temp;
temp = work.KKT[720]-work.L[81]*work.d[361]*1;
residual += temp*temp;
temp = work.KKT[723]-1*work.d[362]*work.L[1129];
residual += temp*temp;
temp = work.KKT[721]-work.L[83]*work.d[361]*1;
residual += temp*temp;
temp = work.KKT[725]-1*work.d[363]*work.L[1130]-work.L[84]*work.d[362]*work.L[1129];
residual += temp*temp;
temp = work.KKT[727]-1*work.d[364]*work.L[86];
residual += temp*temp;
temp = work.KKT[728]-work.L[88]*work.d[365]*1;
residual += temp*temp;
temp = work.KKT[731]-1*work.d[366]*work.L[1163];
residual += temp*temp;
temp = work.KKT[729]-work.L[90]*work.d[365]*1;
residual += temp*temp;
temp = work.KKT[733]-1*work.d[367]*work.L[1164]-work.L[91]*work.d[366]*work.L[1163];
residual += temp*temp;
temp = work.KKT[735]-1*work.d[368]*work.L[93];
residual += temp*temp;
temp = work.KKT[736]-work.L[95]*work.d[369]*1;
residual += temp*temp;
temp = work.KKT[739]-1*work.d[370]*work.L[1197];
residual += temp*temp;
temp = work.KKT[737]-work.L[97]*work.d[369]*1;
residual += temp*temp;
temp = work.KKT[741]-1*work.d[371]*work.L[1198]-work.L[98]*work.d[370]*work.L[1197];
residual += temp*temp;
temp = work.KKT[743]-1*work.d[372]*work.L[100];
residual += temp*temp;
temp = work.KKT[744]-work.L[102]*work.d[373]*1;
residual += temp*temp;
temp = work.KKT[747]-1*work.d[374]*work.L[1231];
residual += temp*temp;
temp = work.KKT[745]-work.L[104]*work.d[373]*1;
residual += temp*temp;
temp = work.KKT[749]-1*work.d[375]*work.L[1232]-work.L[105]*work.d[374]*work.L[1231];
residual += temp*temp;
temp = work.KKT[751]-1*work.d[376]*work.L[107];
residual += temp*temp;
temp = work.KKT[752]-work.L[109]*work.d[377]*1;
residual += temp*temp;
temp = work.KKT[755]-1*work.d[378]*work.L[1265];
residual += temp*temp;
temp = work.KKT[753]-work.L[111]*work.d[377]*1;
residual += temp*temp;
temp = work.KKT[757]-1*work.d[379]*work.L[1266]-work.L[112]*work.d[378]*work.L[1265];
residual += temp*temp;
temp = work.KKT[759]-1*work.d[380]*work.L[114];
residual += temp*temp;
temp = work.KKT[760]-work.L[116]*work.d[381]*1;
residual += temp*temp;
temp = work.KKT[763]-1*work.d[382]*work.L[1299];
residual += temp*temp;
temp = work.KKT[761]-work.L[118]*work.d[381]*1;
residual += temp*temp;
temp = work.KKT[765]-1*work.d[383]*work.L[1300]-work.L[119]*work.d[382]*work.L[1299];
residual += temp*temp;
temp = work.KKT[767]-1*work.d[384]*work.L[121];
residual += temp*temp;
temp = work.KKT[768]-work.L[123]*work.d[385]*1;
residual += temp*temp;
temp = work.KKT[771]-1*work.d[386]*work.L[1333];
residual += temp*temp;
temp = work.KKT[769]-work.L[125]*work.d[385]*1;
residual += temp*temp;
temp = work.KKT[773]-1*work.d[387]*work.L[1334]-work.L[126]*work.d[386]*work.L[1333];
residual += temp*temp;
temp = work.KKT[775]-1*work.d[388]*work.L[128];
residual += temp*temp;
temp = work.KKT[776]-work.L[130]*work.d[389]*1;
residual += temp*temp;
temp = work.KKT[779]-1*work.d[390]*work.L[1367];
residual += temp*temp;
temp = work.KKT[777]-work.L[132]*work.d[389]*1;
residual += temp*temp;
temp = work.KKT[781]-1*work.d[391]*work.L[1368]-work.L[133]*work.d[390]*work.L[1367];
residual += temp*temp;
temp = work.KKT[783]-1*work.d[392]*work.L[135];
residual += temp*temp;
temp = work.KKT[784]-work.L[137]*work.d[393]*1;
residual += temp*temp;
temp = work.KKT[787]-1*work.d[394]*work.L[1401];
residual += temp*temp;
temp = work.KKT[785]-work.L[139]*work.d[393]*1;
residual += temp*temp;
temp = work.KKT[789]-1*work.d[395]*work.L[1402]-work.L[140]*work.d[394]*work.L[1401];
residual += temp*temp;
temp = work.KKT[791]-1*work.d[396]*work.L[142];
residual += temp*temp;
temp = work.KKT[792]-work.L[144]*work.d[397]*1;
residual += temp*temp;
temp = work.KKT[795]-1*work.d[398]*work.L[1435];
residual += temp*temp;
temp = work.KKT[793]-work.L[146]*work.d[397]*1;
residual += temp*temp;
temp = work.KKT[797]-1*work.d[399]*work.L[1436]-work.L[147]*work.d[398]*work.L[1435];
residual += temp*temp;
temp = work.KKT[799]-1*work.d[400]*work.L[149];
residual += temp*temp;
temp = work.KKT[800]-work.L[151]*work.d[401]*1;
residual += temp*temp;
temp = work.KKT[803]-1*work.d[402]*work.L[1469];
residual += temp*temp;
temp = work.KKT[801]-work.L[153]*work.d[401]*1;
residual += temp*temp;
temp = work.KKT[805]-1*work.d[403]*work.L[1470]-work.L[154]*work.d[402]*work.L[1469];
residual += temp*temp;
temp = work.KKT[807]-1*work.d[404]*work.L[156];
residual += temp*temp;
temp = work.KKT[808]-work.L[158]*work.d[405]*1;
residual += temp*temp;
temp = work.KKT[811]-1*work.d[406]*work.L[1489];
residual += temp*temp;
temp = work.KKT[809]-work.L[160]*work.d[405]*1;
residual += temp*temp;
temp = work.KKT[813]-1*work.d[407]*work.L[1490]-work.L[161]*work.d[406]*work.L[1489];
residual += temp*temp;
temp = work.KKT[815]-1*work.d[408]*work.L[163];
residual += temp*temp;
temp = work.KKT[816]-work.L[165]*work.d[409]*1;
residual += temp*temp;
temp = work.KKT[819]-1*work.d[410]*work.L[1514];
residual += temp*temp;
temp = work.KKT[817]-work.L[167]*work.d[409]*1;
residual += temp*temp;
temp = work.KKT[821]-1*work.d[411]*work.L[1515]-work.L[168]*work.d[410]*work.L[1514];
residual += temp*temp;
temp = work.KKT[823]-1*work.d[412]*work.L[170];
residual += temp*temp;
temp = work.KKT[824]-work.L[172]*work.d[413]*1;
residual += temp*temp;
temp = work.KKT[827]-1*work.d[414]*work.L[769];
residual += temp*temp;
temp = work.KKT[825]-work.L[174]*work.d[413]*1;
residual += temp*temp;
temp = work.KKT[829]-1*work.d[415]*work.L[770]-work.L[175]*work.d[414]*work.L[769];
residual += temp*temp;
temp = work.KKT[831]-1*work.d[416]*work.L[177];
residual += temp*temp;
temp = work.KKT[832]-work.L[179]*work.d[417]*1;
residual += temp*temp;
temp = work.KKT[835]-1*work.d[418]*work.L[733];
residual += temp*temp;
temp = work.KKT[833]-work.L[181]*work.d[417]*1;
residual += temp*temp;
temp = work.KKT[837]-1*work.d[419]*work.L[734]-work.L[182]*work.d[418]*work.L[733];
residual += temp*temp;
temp = work.KKT[839]-1*work.d[420]*work.L[184];
residual += temp*temp;
temp = work.KKT[840]-work.L[186]*work.d[421]*1;
residual += temp*temp;
temp = work.KKT[843]-1*work.d[422]*work.L[739];
residual += temp*temp;
temp = work.KKT[841]-work.L[188]*work.d[421]*1;
residual += temp*temp;
temp = work.KKT[845]-1*work.d[423]*work.L[740]-work.L[189]*work.d[422]*work.L[739];
residual += temp*temp;
temp = work.KKT[847]-1*work.d[424]*work.L[191];
residual += temp*temp;
temp = work.KKT[848]-work.L[193]*work.d[425]*1;
residual += temp*temp;
temp = work.KKT[851]-1*work.d[426]*work.L[741];
residual += temp*temp;
temp = work.KKT[852]-1*work.d[426]*work.L[760];
residual += temp*temp;
temp = work.KKT[849]-work.L[195]*work.d[425]*1;
residual += temp*temp;
temp = work.KKT[854]-1*work.d[427]*work.L[742]-work.L[196]*work.d[426]*work.L[741];
residual += temp*temp;
temp = work.KKT[855]-1*work.d[427]*work.L[761]-work.L[196]*work.d[426]*work.L[760];
residual += temp*temp;
temp = work.KKT[857]-1*work.d[428]*work.L[198];
residual += temp*temp;
temp = work.KKT[858]-work.L[200]*work.d[429]*1;
residual += temp*temp;
temp = work.KKT[861]-1*work.d[430]*work.L[762];
residual += temp*temp;
temp = work.KKT[862]-1*work.d[430]*work.L[822];
residual += temp*temp;
temp = work.KKT[859]-work.L[202]*work.d[429]*1;
residual += temp*temp;
temp = work.KKT[864]-1*work.d[431]*work.L[763]-work.L[203]*work.d[430]*work.L[762];
residual += temp*temp;
temp = work.KKT[865]-1*work.d[431]*work.L[823]-work.L[203]*work.d[430]*work.L[822];
residual += temp*temp;
temp = work.KKT[867]-1*work.d[432]*work.L[205];
residual += temp*temp;
temp = work.KKT[868]-work.L[207]*work.d[433]*1;
residual += temp*temp;
temp = work.KKT[871]-1*work.d[434]*work.L[824];
residual += temp*temp;
temp = work.KKT[872]-1*work.d[434]*work.L[859];
residual += temp*temp;
temp = work.KKT[869]-work.L[209]*work.d[433]*1;
residual += temp*temp;
temp = work.KKT[874]-1*work.d[435]*work.L[825]-work.L[210]*work.d[434]*work.L[824];
residual += temp*temp;
temp = work.KKT[875]-1*work.d[435]*work.L[860]-work.L[210]*work.d[434]*work.L[859];
residual += temp*temp;
temp = work.KKT[877]-1*work.d[436]*work.L[212];
residual += temp*temp;
temp = work.KKT[878]-work.L[214]*work.d[437]*1;
residual += temp*temp;
temp = work.KKT[881]-1*work.d[438]*work.L[861];
residual += temp*temp;
temp = work.KKT[882]-1*work.d[438]*work.L[893];
residual += temp*temp;
temp = work.KKT[879]-work.L[216]*work.d[437]*1;
residual += temp*temp;
temp = work.KKT[884]-1*work.d[439]*work.L[862]-work.L[217]*work.d[438]*work.L[861];
residual += temp*temp;
temp = work.KKT[885]-1*work.d[439]*work.L[894]-work.L[217]*work.d[438]*work.L[893];
residual += temp*temp;
temp = work.KKT[887]-1*work.d[440]*work.L[219];
residual += temp*temp;
temp = work.KKT[888]-work.L[221]*work.d[441]*1;
residual += temp*temp;
temp = work.KKT[891]-1*work.d[442]*work.L[895];
residual += temp*temp;
temp = work.KKT[892]-1*work.d[442]*work.L[927];
residual += temp*temp;
temp = work.KKT[889]-work.L[223]*work.d[441]*1;
residual += temp*temp;
temp = work.KKT[894]-1*work.d[443]*work.L[896]-work.L[224]*work.d[442]*work.L[895];
residual += temp*temp;
temp = work.KKT[895]-1*work.d[443]*work.L[928]-work.L[224]*work.d[442]*work.L[927];
residual += temp*temp;
temp = work.KKT[897]-1*work.d[444]*work.L[226];
residual += temp*temp;
temp = work.KKT[898]-work.L[228]*work.d[445]*1;
residual += temp*temp;
temp = work.KKT[901]-1*work.d[446]*work.L[929];
residual += temp*temp;
temp = work.KKT[902]-1*work.d[446]*work.L[961];
residual += temp*temp;
temp = work.KKT[899]-work.L[230]*work.d[445]*1;
residual += temp*temp;
temp = work.KKT[904]-1*work.d[447]*work.L[930]-work.L[231]*work.d[446]*work.L[929];
residual += temp*temp;
temp = work.KKT[905]-1*work.d[447]*work.L[962]-work.L[231]*work.d[446]*work.L[961];
residual += temp*temp;
temp = work.KKT[907]-1*work.d[448]*work.L[233];
residual += temp*temp;
temp = work.KKT[908]-work.L[235]*work.d[449]*1;
residual += temp*temp;
temp = work.KKT[911]-1*work.d[450]*work.L[963];
residual += temp*temp;
temp = work.KKT[912]-1*work.d[450]*work.L[995];
residual += temp*temp;
temp = work.KKT[909]-work.L[237]*work.d[449]*1;
residual += temp*temp;
temp = work.KKT[914]-1*work.d[451]*work.L[964]-work.L[238]*work.d[450]*work.L[963];
residual += temp*temp;
temp = work.KKT[915]-1*work.d[451]*work.L[996]-work.L[238]*work.d[450]*work.L[995];
residual += temp*temp;
temp = work.KKT[917]-1*work.d[452]*work.L[240];
residual += temp*temp;
temp = work.KKT[918]-work.L[242]*work.d[453]*1;
residual += temp*temp;
temp = work.KKT[921]-1*work.d[454]*work.L[997];
residual += temp*temp;
temp = work.KKT[922]-1*work.d[454]*work.L[1029];
residual += temp*temp;
temp = work.KKT[919]-work.L[244]*work.d[453]*1;
residual += temp*temp;
temp = work.KKT[924]-1*work.d[455]*work.L[998]-work.L[245]*work.d[454]*work.L[997];
residual += temp*temp;
temp = work.KKT[925]-1*work.d[455]*work.L[1030]-work.L[245]*work.d[454]*work.L[1029];
residual += temp*temp;
temp = work.KKT[927]-1*work.d[456]*work.L[247];
residual += temp*temp;
temp = work.KKT[928]-work.L[249]*work.d[457]*1;
residual += temp*temp;
temp = work.KKT[931]-1*work.d[458]*work.L[1031];
residual += temp*temp;
temp = work.KKT[932]-1*work.d[458]*work.L[1063];
residual += temp*temp;
temp = work.KKT[929]-work.L[251]*work.d[457]*1;
residual += temp*temp;
temp = work.KKT[934]-1*work.d[459]*work.L[1032]-work.L[252]*work.d[458]*work.L[1031];
residual += temp*temp;
temp = work.KKT[935]-1*work.d[459]*work.L[1064]-work.L[252]*work.d[458]*work.L[1063];
residual += temp*temp;
temp = work.KKT[937]-1*work.d[460]*work.L[254];
residual += temp*temp;
temp = work.KKT[938]-work.L[256]*work.d[461]*1;
residual += temp*temp;
temp = work.KKT[941]-1*work.d[462]*work.L[1065];
residual += temp*temp;
temp = work.KKT[942]-1*work.d[462]*work.L[1097];
residual += temp*temp;
temp = work.KKT[939]-work.L[258]*work.d[461]*1;
residual += temp*temp;
temp = work.KKT[944]-1*work.d[463]*work.L[1066]-work.L[259]*work.d[462]*work.L[1065];
residual += temp*temp;
temp = work.KKT[945]-1*work.d[463]*work.L[1098]-work.L[259]*work.d[462]*work.L[1097];
residual += temp*temp;
temp = work.KKT[947]-1*work.d[464]*work.L[261];
residual += temp*temp;
temp = work.KKT[948]-work.L[263]*work.d[465]*1;
residual += temp*temp;
temp = work.KKT[951]-1*work.d[466]*work.L[1099];
residual += temp*temp;
temp = work.KKT[952]-1*work.d[466]*work.L[1131];
residual += temp*temp;
temp = work.KKT[949]-work.L[265]*work.d[465]*1;
residual += temp*temp;
temp = work.KKT[954]-1*work.d[467]*work.L[1100]-work.L[266]*work.d[466]*work.L[1099];
residual += temp*temp;
temp = work.KKT[955]-1*work.d[467]*work.L[1132]-work.L[266]*work.d[466]*work.L[1131];
residual += temp*temp;
temp = work.KKT[957]-1*work.d[468]*work.L[268];
residual += temp*temp;
temp = work.KKT[958]-work.L[270]*work.d[469]*1;
residual += temp*temp;
temp = work.KKT[961]-1*work.d[470]*work.L[1133];
residual += temp*temp;
temp = work.KKT[962]-1*work.d[470]*work.L[1165];
residual += temp*temp;
temp = work.KKT[959]-work.L[272]*work.d[469]*1;
residual += temp*temp;
temp = work.KKT[964]-1*work.d[471]*work.L[1134]-work.L[273]*work.d[470]*work.L[1133];
residual += temp*temp;
temp = work.KKT[965]-1*work.d[471]*work.L[1166]-work.L[273]*work.d[470]*work.L[1165];
residual += temp*temp;
temp = work.KKT[967]-1*work.d[472]*work.L[275];
residual += temp*temp;
temp = work.KKT[968]-work.L[277]*work.d[473]*1;
residual += temp*temp;
temp = work.KKT[971]-1*work.d[474]*work.L[1167];
residual += temp*temp;
temp = work.KKT[972]-1*work.d[474]*work.L[1199];
residual += temp*temp;
temp = work.KKT[969]-work.L[279]*work.d[473]*1;
residual += temp*temp;
temp = work.KKT[974]-1*work.d[475]*work.L[1168]-work.L[280]*work.d[474]*work.L[1167];
residual += temp*temp;
temp = work.KKT[975]-1*work.d[475]*work.L[1200]-work.L[280]*work.d[474]*work.L[1199];
residual += temp*temp;
temp = work.KKT[977]-1*work.d[476]*work.L[282];
residual += temp*temp;
temp = work.KKT[978]-work.L[284]*work.d[477]*1;
residual += temp*temp;
temp = work.KKT[981]-1*work.d[478]*work.L[1201];
residual += temp*temp;
temp = work.KKT[982]-1*work.d[478]*work.L[1233];
residual += temp*temp;
temp = work.KKT[979]-work.L[286]*work.d[477]*1;
residual += temp*temp;
temp = work.KKT[984]-1*work.d[479]*work.L[1202]-work.L[287]*work.d[478]*work.L[1201];
residual += temp*temp;
temp = work.KKT[985]-1*work.d[479]*work.L[1234]-work.L[287]*work.d[478]*work.L[1233];
residual += temp*temp;
temp = work.KKT[987]-1*work.d[480]*work.L[289];
residual += temp*temp;
temp = work.KKT[988]-work.L[291]*work.d[481]*1;
residual += temp*temp;
temp = work.KKT[991]-1*work.d[482]*work.L[1235];
residual += temp*temp;
temp = work.KKT[992]-1*work.d[482]*work.L[1267];
residual += temp*temp;
temp = work.KKT[989]-work.L[293]*work.d[481]*1;
residual += temp*temp;
temp = work.KKT[994]-1*work.d[483]*work.L[1236]-work.L[294]*work.d[482]*work.L[1235];
residual += temp*temp;
temp = work.KKT[995]-1*work.d[483]*work.L[1268]-work.L[294]*work.d[482]*work.L[1267];
residual += temp*temp;
temp = work.KKT[997]-1*work.d[484]*work.L[296];
residual += temp*temp;
temp = work.KKT[998]-work.L[298]*work.d[485]*1;
residual += temp*temp;
temp = work.KKT[1001]-1*work.d[486]*work.L[1269];
residual += temp*temp;
temp = work.KKT[1002]-1*work.d[486]*work.L[1301];
residual += temp*temp;
temp = work.KKT[999]-work.L[300]*work.d[485]*1;
residual += temp*temp;
temp = work.KKT[1004]-1*work.d[487]*work.L[1270]-work.L[301]*work.d[486]*work.L[1269];
residual += temp*temp;
temp = work.KKT[1005]-1*work.d[487]*work.L[1302]-work.L[301]*work.d[486]*work.L[1301];
residual += temp*temp;
temp = work.KKT[1007]-1*work.d[488]*work.L[303];
residual += temp*temp;
temp = work.KKT[1008]-work.L[305]*work.d[489]*1;
residual += temp*temp;
temp = work.KKT[1011]-1*work.d[490]*work.L[1303];
residual += temp*temp;
temp = work.KKT[1012]-1*work.d[490]*work.L[1335];
residual += temp*temp;
temp = work.KKT[1009]-work.L[307]*work.d[489]*1;
residual += temp*temp;
temp = work.KKT[1014]-1*work.d[491]*work.L[1304]-work.L[308]*work.d[490]*work.L[1303];
residual += temp*temp;
temp = work.KKT[1015]-1*work.d[491]*work.L[1336]-work.L[308]*work.d[490]*work.L[1335];
residual += temp*temp;
temp = work.KKT[1017]-1*work.d[492]*work.L[310];
residual += temp*temp;
temp = work.KKT[1018]-work.L[312]*work.d[493]*1;
residual += temp*temp;
temp = work.KKT[1021]-1*work.d[494]*work.L[1337];
residual += temp*temp;
temp = work.KKT[1022]-1*work.d[494]*work.L[1369];
residual += temp*temp;
temp = work.KKT[1019]-work.L[314]*work.d[493]*1;
residual += temp*temp;
temp = work.KKT[1024]-1*work.d[495]*work.L[1338]-work.L[315]*work.d[494]*work.L[1337];
residual += temp*temp;
temp = work.KKT[1025]-1*work.d[495]*work.L[1370]-work.L[315]*work.d[494]*work.L[1369];
residual += temp*temp;
temp = work.KKT[1027]-1*work.d[496]*work.L[317];
residual += temp*temp;
temp = work.KKT[1028]-work.L[319]*work.d[497]*1;
residual += temp*temp;
temp = work.KKT[1031]-1*work.d[498]*work.L[1371];
residual += temp*temp;
temp = work.KKT[1032]-1*work.d[498]*work.L[1403];
residual += temp*temp;
temp = work.KKT[1029]-work.L[321]*work.d[497]*1;
residual += temp*temp;
temp = work.KKT[1034]-1*work.d[499]*work.L[1372]-work.L[322]*work.d[498]*work.L[1371];
residual += temp*temp;
temp = work.KKT[1035]-1*work.d[499]*work.L[1404]-work.L[322]*work.d[498]*work.L[1403];
residual += temp*temp;
temp = work.KKT[1037]-1*work.d[500]*work.L[324];
residual += temp*temp;
temp = work.KKT[1038]-work.L[326]*work.d[501]*1;
residual += temp*temp;
temp = work.KKT[1041]-1*work.d[502]*work.L[1405];
residual += temp*temp;
temp = work.KKT[1042]-1*work.d[502]*work.L[1437];
residual += temp*temp;
temp = work.KKT[1039]-work.L[328]*work.d[501]*1;
residual += temp*temp;
temp = work.KKT[1044]-1*work.d[503]*work.L[1406]-work.L[329]*work.d[502]*work.L[1405];
residual += temp*temp;
temp = work.KKT[1045]-1*work.d[503]*work.L[1438]-work.L[329]*work.d[502]*work.L[1437];
residual += temp*temp;
temp = work.KKT[1047]-1*work.d[504]*work.L[331];
residual += temp*temp;
temp = work.KKT[1048]-work.L[333]*work.d[505]*1;
residual += temp*temp;
temp = work.KKT[1051]-1*work.d[506]*work.L[1439];
residual += temp*temp;
temp = work.KKT[1052]-1*work.d[506]*work.L[1471];
residual += temp*temp;
temp = work.KKT[1049]-work.L[335]*work.d[505]*1;
residual += temp*temp;
temp = work.KKT[1054]-1*work.d[507]*work.L[1440]-work.L[336]*work.d[506]*work.L[1439];
residual += temp*temp;
temp = work.KKT[1055]-1*work.d[507]*work.L[1472]-work.L[336]*work.d[506]*work.L[1471];
residual += temp*temp;
temp = work.KKT[1057]-1*work.d[508]*work.L[338];
residual += temp*temp;
temp = work.KKT[1058]-work.L[340]*work.d[509]*1;
residual += temp*temp;
temp = work.KKT[1061]-1*work.d[510]*work.L[1473];
residual += temp*temp;
temp = work.KKT[1062]-1*work.d[510]*work.L[1491];
residual += temp*temp;
temp = work.KKT[1059]-work.L[342]*work.d[509]*1;
residual += temp*temp;
temp = work.KKT[1064]-1*work.d[511]*work.L[1474]-work.L[343]*work.d[510]*work.L[1473];
residual += temp*temp;
temp = work.KKT[1065]-1*work.d[511]*work.L[1492]-work.L[343]*work.d[510]*work.L[1491];
residual += temp*temp;
temp = work.KKT[1067]-1*work.d[512]*work.L[345];
residual += temp*temp;
temp = work.KKT[1068]-work.L[347]*work.d[513]*1;
residual += temp*temp;
temp = work.KKT[1071]-1*work.d[514]*work.L[1493];
residual += temp*temp;
temp = work.KKT[1072]-1*work.d[514]*work.L[1516];
residual += temp*temp;
temp = work.KKT[1069]-work.L[349]*work.d[513]*1;
residual += temp*temp;
temp = work.KKT[1074]-1*work.d[515]*work.L[1494]-work.L[350]*work.d[514]*work.L[1493];
residual += temp*temp;
temp = work.KKT[1075]-1*work.d[515]*work.L[1517]-work.L[350]*work.d[514]*work.L[1516];
residual += temp*temp;
temp = work.KKT[1077]-1*work.d[516]*work.L[352];
residual += temp*temp;
temp = work.KKT[1078]-work.L[354]*work.d[517]*1;
residual += temp*temp;
temp = work.KKT[1082]-1*work.d[518]*work.L[1518];
residual += temp*temp;
temp = work.KKT[1081]-1*work.d[518]*work.L[771];
residual += temp*temp;
temp = work.KKT[1079]-work.L[356]*work.d[517]*1;
residual += temp*temp;
temp = work.KKT[1085]-1*work.d[519]*work.L[1519]-work.L[357]*work.d[518]*work.L[1518];
residual += temp*temp;
temp = work.KKT[1084]-1*work.d[519]*work.L[772]-work.L[357]*work.d[518]*work.L[771];
residual += temp*temp;
temp = work.KKT[1087]-1*work.d[520]*work.L[359];
residual += temp*temp;
temp = work.KKT[1088]-work.L[361]*work.d[521]*1;
residual += temp*temp;
temp = work.KKT[1092]-1*work.d[522]*work.L[773];
residual += temp*temp;
temp = work.KKT[1091]-1*work.d[522]*work.L[735];
residual += temp*temp;
temp = work.KKT[1089]-work.L[363]*work.d[521]*1;
residual += temp*temp;
temp = work.KKT[1095]-1*work.d[523]*work.L[774]-work.L[364]*work.d[522]*work.L[773];
residual += temp*temp;
temp = work.KKT[1094]-1*work.d[523]*work.L[736]-work.L[364]*work.d[522]*work.L[735];
residual += temp*temp;
temp = work.KKT[1097]-1*work.d[524]*work.L[366];
residual += temp*temp;
temp = work.KKT[1098]-work.L[368]*work.d[525]*1;
residual += temp*temp;
temp = work.KKT[1101]-1*work.d[526]*work.L[750];
residual += temp*temp;
temp = work.KKT[1099]-work.L[370]*work.d[525]*1;
residual += temp*temp;
temp = work.KKT[1103]-1*work.d[527]*work.L[751]-work.L[371]*work.d[526]*work.L[750];
residual += temp*temp;
temp = work.KKT[1105]-1*work.d[528]*work.L[373];
residual += temp*temp;
temp = work.KKT[1106]-work.L[375]*work.d[529]*1;
residual += temp*temp;
temp = work.KKT[1109]-1*work.d[530]*work.L[786];
residual += temp*temp;
temp = work.KKT[1107]-work.L[377]*work.d[529]*1;
residual += temp*temp;
temp = work.KKT[1111]-1*work.d[531]*work.L[787]-work.L[378]*work.d[530]*work.L[786];
residual += temp*temp;
temp = work.KKT[1113]-1*work.d[532]*work.L[380];
residual += temp*temp;
temp = work.KKT[1114]-work.L[382]*work.d[533]*1;
residual += temp*temp;
temp = work.KKT[1117]-1*work.d[534]*work.L[808];
residual += temp*temp;
temp = work.KKT[1115]-work.L[384]*work.d[533]*1;
residual += temp*temp;
temp = work.KKT[1119]-1*work.d[535]*work.L[809]-work.L[385]*work.d[534]*work.L[808];
residual += temp*temp;
temp = work.KKT[1121]-1*work.d[536]*work.L[387];
residual += temp*temp;
temp = work.KKT[1122]-work.L[389]*work.d[537]*1;
residual += temp*temp;
temp = work.KKT[1125]-1*work.d[538]*work.L[843];
residual += temp*temp;
temp = work.KKT[1123]-work.L[391]*work.d[537]*1;
residual += temp*temp;
temp = work.KKT[1127]-1*work.d[539]*work.L[844]-work.L[392]*work.d[538]*work.L[843];
residual += temp*temp;
temp = work.KKT[1129]-1*work.d[540]*work.L[394];
residual += temp*temp;
temp = work.KKT[1130]-work.L[396]*work.d[541]*1;
residual += temp*temp;
temp = work.KKT[1133]-1*work.d[542]*work.L[877];
residual += temp*temp;
temp = work.KKT[1131]-work.L[398]*work.d[541]*1;
residual += temp*temp;
temp = work.KKT[1135]-1*work.d[543]*work.L[878]-work.L[399]*work.d[542]*work.L[877];
residual += temp*temp;
temp = work.KKT[1137]-1*work.d[544]*work.L[401];
residual += temp*temp;
temp = work.KKT[1138]-work.L[403]*work.d[545]*1;
residual += temp*temp;
temp = work.KKT[1141]-1*work.d[546]*work.L[911];
residual += temp*temp;
temp = work.KKT[1139]-work.L[405]*work.d[545]*1;
residual += temp*temp;
temp = work.KKT[1143]-1*work.d[547]*work.L[912]-work.L[406]*work.d[546]*work.L[911];
residual += temp*temp;
temp = work.KKT[1145]-1*work.d[548]*work.L[408];
residual += temp*temp;
temp = work.KKT[1146]-work.L[410]*work.d[549]*1;
residual += temp*temp;
temp = work.KKT[1149]-1*work.d[550]*work.L[945];
residual += temp*temp;
temp = work.KKT[1147]-work.L[412]*work.d[549]*1;
residual += temp*temp;
temp = work.KKT[1151]-1*work.d[551]*work.L[946]-work.L[413]*work.d[550]*work.L[945];
residual += temp*temp;
temp = work.KKT[1153]-1*work.d[552]*work.L[415];
residual += temp*temp;
temp = work.KKT[1154]-work.L[417]*work.d[553]*1;
residual += temp*temp;
temp = work.KKT[1157]-1*work.d[554]*work.L[979];
residual += temp*temp;
temp = work.KKT[1155]-work.L[419]*work.d[553]*1;
residual += temp*temp;
temp = work.KKT[1159]-1*work.d[555]*work.L[980]-work.L[420]*work.d[554]*work.L[979];
residual += temp*temp;
temp = work.KKT[1161]-1*work.d[556]*work.L[422];
residual += temp*temp;
temp = work.KKT[1162]-work.L[424]*work.d[557]*1;
residual += temp*temp;
temp = work.KKT[1165]-1*work.d[558]*work.L[1013];
residual += temp*temp;
temp = work.KKT[1163]-work.L[426]*work.d[557]*1;
residual += temp*temp;
temp = work.KKT[1167]-1*work.d[559]*work.L[1014]-work.L[427]*work.d[558]*work.L[1013];
residual += temp*temp;
temp = work.KKT[1169]-1*work.d[560]*work.L[429];
residual += temp*temp;
temp = work.KKT[1170]-work.L[431]*work.d[561]*1;
residual += temp*temp;
temp = work.KKT[1173]-1*work.d[562]*work.L[1047];
residual += temp*temp;
temp = work.KKT[1171]-work.L[433]*work.d[561]*1;
residual += temp*temp;
temp = work.KKT[1175]-1*work.d[563]*work.L[1048]-work.L[434]*work.d[562]*work.L[1047];
residual += temp*temp;
temp = work.KKT[1177]-1*work.d[564]*work.L[436];
residual += temp*temp;
temp = work.KKT[1178]-work.L[438]*work.d[565]*1;
residual += temp*temp;
temp = work.KKT[1181]-1*work.d[566]*work.L[1081];
residual += temp*temp;
temp = work.KKT[1179]-work.L[440]*work.d[565]*1;
residual += temp*temp;
temp = work.KKT[1183]-1*work.d[567]*work.L[1082]-work.L[441]*work.d[566]*work.L[1081];
residual += temp*temp;
temp = work.KKT[1185]-1*work.d[568]*work.L[443];
residual += temp*temp;
temp = work.KKT[1186]-work.L[445]*work.d[569]*1;
residual += temp*temp;
temp = work.KKT[1189]-1*work.d[570]*work.L[1115];
residual += temp*temp;
temp = work.KKT[1187]-work.L[447]*work.d[569]*1;
residual += temp*temp;
temp = work.KKT[1191]-1*work.d[571]*work.L[1116]-work.L[448]*work.d[570]*work.L[1115];
residual += temp*temp;
temp = work.KKT[1193]-1*work.d[572]*work.L[450];
residual += temp*temp;
temp = work.KKT[1194]-work.L[452]*work.d[573]*1;
residual += temp*temp;
temp = work.KKT[1197]-1*work.d[574]*work.L[1149];
residual += temp*temp;
temp = work.KKT[1195]-work.L[454]*work.d[573]*1;
residual += temp*temp;
temp = work.KKT[1199]-1*work.d[575]*work.L[1150]-work.L[455]*work.d[574]*work.L[1149];
residual += temp*temp;
temp = work.KKT[1201]-1*work.d[576]*work.L[457];
residual += temp*temp;
temp = work.KKT[1202]-work.L[459]*work.d[577]*1;
residual += temp*temp;
temp = work.KKT[1205]-1*work.d[578]*work.L[1183];
residual += temp*temp;
temp = work.KKT[1203]-work.L[461]*work.d[577]*1;
residual += temp*temp;
temp = work.KKT[1207]-1*work.d[579]*work.L[1184]-work.L[462]*work.d[578]*work.L[1183];
residual += temp*temp;
temp = work.KKT[1209]-1*work.d[580]*work.L[464];
residual += temp*temp;
temp = work.KKT[1210]-work.L[466]*work.d[581]*1;
residual += temp*temp;
temp = work.KKT[1213]-1*work.d[582]*work.L[1217];
residual += temp*temp;
temp = work.KKT[1211]-work.L[468]*work.d[581]*1;
residual += temp*temp;
temp = work.KKT[1215]-1*work.d[583]*work.L[1218]-work.L[469]*work.d[582]*work.L[1217];
residual += temp*temp;
temp = work.KKT[1217]-1*work.d[584]*work.L[471];
residual += temp*temp;
temp = work.KKT[1218]-work.L[473]*work.d[585]*1;
residual += temp*temp;
temp = work.KKT[1221]-1*work.d[586]*work.L[1251];
residual += temp*temp;
temp = work.KKT[1219]-work.L[475]*work.d[585]*1;
residual += temp*temp;
temp = work.KKT[1223]-1*work.d[587]*work.L[1252]-work.L[476]*work.d[586]*work.L[1251];
residual += temp*temp;
temp = work.KKT[1225]-1*work.d[588]*work.L[478];
residual += temp*temp;
temp = work.KKT[1226]-work.L[480]*work.d[589]*1;
residual += temp*temp;
temp = work.KKT[1229]-1*work.d[590]*work.L[1285];
residual += temp*temp;
temp = work.KKT[1227]-work.L[482]*work.d[589]*1;
residual += temp*temp;
temp = work.KKT[1231]-1*work.d[591]*work.L[1286]-work.L[483]*work.d[590]*work.L[1285];
residual += temp*temp;
temp = work.KKT[1233]-1*work.d[592]*work.L[485];
residual += temp*temp;
temp = work.KKT[1234]-work.L[487]*work.d[593]*1;
residual += temp*temp;
temp = work.KKT[1237]-1*work.d[594]*work.L[1319];
residual += temp*temp;
temp = work.KKT[1235]-work.L[489]*work.d[593]*1;
residual += temp*temp;
temp = work.KKT[1239]-1*work.d[595]*work.L[1320]-work.L[490]*work.d[594]*work.L[1319];
residual += temp*temp;
temp = work.KKT[1241]-1*work.d[596]*work.L[492];
residual += temp*temp;
temp = work.KKT[1242]-work.L[494]*work.d[597]*1;
residual += temp*temp;
temp = work.KKT[1245]-1*work.d[598]*work.L[1353];
residual += temp*temp;
temp = work.KKT[1243]-work.L[496]*work.d[597]*1;
residual += temp*temp;
temp = work.KKT[1247]-1*work.d[599]*work.L[1354]-work.L[497]*work.d[598]*work.L[1353];
residual += temp*temp;
temp = work.KKT[1249]-1*work.d[600]*work.L[499];
residual += temp*temp;
temp = work.KKT[1250]-work.L[501]*work.d[601]*1;
residual += temp*temp;
temp = work.KKT[1253]-1*work.d[602]*work.L[1387];
residual += temp*temp;
temp = work.KKT[1251]-work.L[503]*work.d[601]*1;
residual += temp*temp;
temp = work.KKT[1255]-1*work.d[603]*work.L[1388]-work.L[504]*work.d[602]*work.L[1387];
residual += temp*temp;
temp = work.KKT[1257]-1*work.d[604]*work.L[506];
residual += temp*temp;
temp = work.KKT[1258]-work.L[508]*work.d[605]*1;
residual += temp*temp;
temp = work.KKT[1261]-1*work.d[606]*work.L[1421];
residual += temp*temp;
temp = work.KKT[1259]-work.L[510]*work.d[605]*1;
residual += temp*temp;
temp = work.KKT[1263]-1*work.d[607]*work.L[1422]-work.L[511]*work.d[606]*work.L[1421];
residual += temp*temp;
temp = work.KKT[1265]-1*work.d[608]*work.L[513];
residual += temp*temp;
temp = work.KKT[1266]-work.L[515]*work.d[609]*1;
residual += temp*temp;
temp = work.KKT[1269]-1*work.d[610]*work.L[1455];
residual += temp*temp;
temp = work.KKT[1267]-work.L[517]*work.d[609]*1;
residual += temp*temp;
temp = work.KKT[1271]-1*work.d[611]*work.L[1456]-work.L[518]*work.d[610]*work.L[1455];
residual += temp*temp;
temp = work.KKT[1273]-1*work.d[612]*work.L[520];
residual += temp*temp;
temp = work.KKT[1274]-work.L[522]*work.d[613]*1;
residual += temp*temp;
temp = work.KKT[1277]-1*work.d[614]*work.L[1536];
residual += temp*temp;
temp = work.KKT[1275]-work.L[524]*work.d[613]*1;
residual += temp*temp;
temp = work.KKT[1279]-1*work.d[615]*work.L[1537]-work.L[525]*work.d[614]*work.L[1536];
residual += temp*temp;
temp = work.KKT[1281]-1*work.d[616]*work.L[527];
residual += temp*temp;
temp = work.KKT[1282]-work.L[529]*work.d[617]*1;
residual += temp*temp;
temp = work.KKT[1285]-1*work.d[618]*work.L[1558];
residual += temp*temp;
temp = work.KKT[1283]-work.L[531]*work.d[617]*1;
residual += temp*temp;
temp = work.KKT[1287]-1*work.d[619]*work.L[1559]-work.L[532]*work.d[618]*work.L[1558];
residual += temp*temp;
temp = work.KKT[1289]-1*work.d[620]*work.L[534];
residual += temp*temp;
temp = work.KKT[1290]-work.L[536]*work.d[621]*1;
residual += temp*temp;
temp = work.KKT[1293]-1*work.d[622]*work.L[1498];
residual += temp*temp;
temp = work.KKT[1291]-work.L[538]*work.d[621]*1;
residual += temp*temp;
temp = work.KKT[1295]-1*work.d[623]*work.L[1499]-work.L[539]*work.d[622]*work.L[1498];
residual += temp*temp;
temp = work.KKT[1297]-1*work.d[624]*work.L[541];
residual += temp*temp;
temp = work.KKT[1298]-work.L[543]*work.d[625]*1;
residual += temp*temp;
temp = work.KKT[1301]-1*work.d[626]*work.L[547];
residual += temp*temp;
temp = work.KKT[1299]-work.L[545]*work.d[625]*1;
residual += temp*temp;
temp = work.KKT[1303]-1*work.d[627]*work.L[548]-work.L[546]*work.d[626]*work.L[547];
residual += temp*temp;
temp = work.KKT[1307]-1*work.d[629]*work.L[550];
residual += temp*temp;
temp = work.KKT[1308]-work.L[552]*work.d[630]*1;
residual += temp*temp;
temp = work.KKT[1311]-1*work.d[631]*work.L[790];
residual += temp*temp;
temp = work.KKT[1309]-work.L[554]*work.d[630]*1;
residual += temp*temp;
temp = work.KKT[1313]-1*work.d[632]*work.L[791]-work.L[555]*work.d[631]*work.L[790];
residual += temp*temp;
temp = work.KKT[1315]-1*work.d[633]*work.L[557];
residual += temp*temp;
temp = work.KKT[1316]-work.L[559]*work.d[634]*1;
residual += temp*temp;
temp = work.KKT[1319]-1*work.d[635]*work.L[799];
residual += temp*temp;
temp = work.KKT[1317]-work.L[561]*work.d[634]*1;
residual += temp*temp;
temp = work.KKT[1321]-1*work.d[636]*work.L[800]-work.L[562]*work.d[635]*work.L[799];
residual += temp*temp;
temp = work.KKT[1323]-1*work.d[637]*work.L[564];
residual += temp*temp;
temp = work.KKT[1324]-work.L[566]*work.d[638]*1;
residual += temp*temp;
temp = work.KKT[1327]-1*work.d[639]*work.L[833];
residual += temp*temp;
temp = work.KKT[1325]-work.L[568]*work.d[638]*1;
residual += temp*temp;
temp = work.KKT[1329]-1*work.d[640]*work.L[834]-work.L[569]*work.d[639]*work.L[833];
residual += temp*temp;
temp = work.KKT[1331]-1*work.d[641]*work.L[571];
residual += temp*temp;
temp = work.KKT[1332]-work.L[573]*work.d[642]*1;
residual += temp*temp;
temp = work.KKT[1335]-1*work.d[643]*work.L[868];
residual += temp*temp;
temp = work.KKT[1333]-work.L[575]*work.d[642]*1;
residual += temp*temp;
temp = work.KKT[1337]-1*work.d[644]*work.L[869]-work.L[576]*work.d[643]*work.L[868];
residual += temp*temp;
temp = work.KKT[1339]-1*work.d[645]*work.L[578];
residual += temp*temp;
temp = work.KKT[1340]-work.L[580]*work.d[646]*1;
residual += temp*temp;
temp = work.KKT[1343]-1*work.d[647]*work.L[902];
residual += temp*temp;
temp = work.KKT[1341]-work.L[582]*work.d[646]*1;
residual += temp*temp;
temp = work.KKT[1345]-1*work.d[648]*work.L[903]-work.L[583]*work.d[647]*work.L[902];
residual += temp*temp;
temp = work.KKT[1347]-1*work.d[649]*work.L[585];
residual += temp*temp;
temp = work.KKT[1348]-work.L[587]*work.d[650]*1;
residual += temp*temp;
temp = work.KKT[1351]-1*work.d[651]*work.L[936];
residual += temp*temp;
temp = work.KKT[1349]-work.L[589]*work.d[650]*1;
residual += temp*temp;
temp = work.KKT[1353]-1*work.d[652]*work.L[937]-work.L[590]*work.d[651]*work.L[936];
residual += temp*temp;
temp = work.KKT[1355]-1*work.d[653]*work.L[592];
residual += temp*temp;
temp = work.KKT[1356]-work.L[594]*work.d[654]*1;
residual += temp*temp;
temp = work.KKT[1359]-1*work.d[655]*work.L[970];
residual += temp*temp;
temp = work.KKT[1357]-work.L[596]*work.d[654]*1;
residual += temp*temp;
temp = work.KKT[1361]-1*work.d[656]*work.L[971]-work.L[597]*work.d[655]*work.L[970];
residual += temp*temp;
temp = work.KKT[1363]-1*work.d[657]*work.L[599];
residual += temp*temp;
temp = work.KKT[1364]-work.L[601]*work.d[658]*1;
residual += temp*temp;
temp = work.KKT[1367]-1*work.d[659]*work.L[1004];
residual += temp*temp;
temp = work.KKT[1365]-work.L[603]*work.d[658]*1;
residual += temp*temp;
temp = work.KKT[1369]-1*work.d[660]*work.L[1005]-work.L[604]*work.d[659]*work.L[1004];
residual += temp*temp;
temp = work.KKT[1371]-1*work.d[661]*work.L[606];
residual += temp*temp;
temp = work.KKT[1372]-work.L[608]*work.d[662]*1;
residual += temp*temp;
temp = work.KKT[1375]-1*work.d[663]*work.L[1038];
residual += temp*temp;
temp = work.KKT[1373]-work.L[610]*work.d[662]*1;
residual += temp*temp;
temp = work.KKT[1377]-1*work.d[664]*work.L[1039]-work.L[611]*work.d[663]*work.L[1038];
residual += temp*temp;
temp = work.KKT[1379]-1*work.d[665]*work.L[613];
residual += temp*temp;
temp = work.KKT[1380]-work.L[615]*work.d[666]*1;
residual += temp*temp;
temp = work.KKT[1383]-1*work.d[667]*work.L[1072];
residual += temp*temp;
temp = work.KKT[1381]-work.L[617]*work.d[666]*1;
residual += temp*temp;
temp = work.KKT[1385]-1*work.d[668]*work.L[1073]-work.L[618]*work.d[667]*work.L[1072];
residual += temp*temp;
temp = work.KKT[1387]-1*work.d[669]*work.L[620];
residual += temp*temp;
temp = work.KKT[1388]-work.L[622]*work.d[670]*1;
residual += temp*temp;
temp = work.KKT[1391]-1*work.d[671]*work.L[1106];
residual += temp*temp;
temp = work.KKT[1389]-work.L[624]*work.d[670]*1;
residual += temp*temp;
temp = work.KKT[1393]-1*work.d[672]*work.L[1107]-work.L[625]*work.d[671]*work.L[1106];
residual += temp*temp;
temp = work.KKT[1395]-1*work.d[673]*work.L[627];
residual += temp*temp;
temp = work.KKT[1396]-work.L[629]*work.d[674]*1;
residual += temp*temp;
temp = work.KKT[1399]-1*work.d[675]*work.L[1140];
residual += temp*temp;
temp = work.KKT[1397]-work.L[631]*work.d[674]*1;
residual += temp*temp;
temp = work.KKT[1401]-1*work.d[676]*work.L[1141]-work.L[632]*work.d[675]*work.L[1140];
residual += temp*temp;
temp = work.KKT[1403]-1*work.d[677]*work.L[634];
residual += temp*temp;
temp = work.KKT[1404]-work.L[636]*work.d[678]*1;
residual += temp*temp;
temp = work.KKT[1407]-1*work.d[679]*work.L[1174];
residual += temp*temp;
temp = work.KKT[1405]-work.L[638]*work.d[678]*1;
residual += temp*temp;
temp = work.KKT[1409]-1*work.d[680]*work.L[1175]-work.L[639]*work.d[679]*work.L[1174];
residual += temp*temp;
temp = work.KKT[1411]-1*work.d[681]*work.L[641];
residual += temp*temp;
temp = work.KKT[1412]-work.L[643]*work.d[682]*1;
residual += temp*temp;
temp = work.KKT[1415]-1*work.d[683]*work.L[1208];
residual += temp*temp;
temp = work.KKT[1413]-work.L[645]*work.d[682]*1;
residual += temp*temp;
temp = work.KKT[1417]-1*work.d[684]*work.L[1209]-work.L[646]*work.d[683]*work.L[1208];
residual += temp*temp;
temp = work.KKT[1419]-1*work.d[685]*work.L[648];
residual += temp*temp;
temp = work.KKT[1420]-work.L[650]*work.d[686]*1;
residual += temp*temp;
temp = work.KKT[1423]-1*work.d[687]*work.L[1242];
residual += temp*temp;
temp = work.KKT[1421]-work.L[652]*work.d[686]*1;
residual += temp*temp;
temp = work.KKT[1425]-1*work.d[688]*work.L[1243]-work.L[653]*work.d[687]*work.L[1242];
residual += temp*temp;
temp = work.KKT[1427]-1*work.d[689]*work.L[655];
residual += temp*temp;
temp = work.KKT[1428]-work.L[657]*work.d[690]*1;
residual += temp*temp;
temp = work.KKT[1431]-1*work.d[691]*work.L[1276];
residual += temp*temp;
temp = work.KKT[1429]-work.L[659]*work.d[690]*1;
residual += temp*temp;
temp = work.KKT[1433]-1*work.d[692]*work.L[1277]-work.L[660]*work.d[691]*work.L[1276];
residual += temp*temp;
temp = work.KKT[1435]-1*work.d[693]*work.L[662];
residual += temp*temp;
temp = work.KKT[1436]-work.L[664]*work.d[694]*1;
residual += temp*temp;
temp = work.KKT[1439]-1*work.d[695]*work.L[1310];
residual += temp*temp;
temp = work.KKT[1437]-work.L[666]*work.d[694]*1;
residual += temp*temp;
temp = work.KKT[1441]-1*work.d[696]*work.L[1311]-work.L[667]*work.d[695]*work.L[1310];
residual += temp*temp;
temp = work.KKT[1443]-1*work.d[697]*work.L[669];
residual += temp*temp;
temp = work.KKT[1444]-work.L[671]*work.d[698]*1;
residual += temp*temp;
temp = work.KKT[1447]-1*work.d[699]*work.L[1344];
residual += temp*temp;
temp = work.KKT[1445]-work.L[673]*work.d[698]*1;
residual += temp*temp;
temp = work.KKT[1449]-1*work.d[700]*work.L[1345]-work.L[674]*work.d[699]*work.L[1344];
residual += temp*temp;
temp = work.KKT[1451]-1*work.d[701]*work.L[676];
residual += temp*temp;
temp = work.KKT[1452]-work.L[678]*work.d[702]*1;
residual += temp*temp;
temp = work.KKT[1455]-1*work.d[703]*work.L[1378];
residual += temp*temp;
temp = work.KKT[1453]-work.L[680]*work.d[702]*1;
residual += temp*temp;
temp = work.KKT[1457]-1*work.d[704]*work.L[1379]-work.L[681]*work.d[703]*work.L[1378];
residual += temp*temp;
temp = work.KKT[1459]-1*work.d[705]*work.L[683];
residual += temp*temp;
temp = work.KKT[1460]-work.L[685]*work.d[706]*1;
residual += temp*temp;
temp = work.KKT[1463]-1*work.d[707]*work.L[1412];
residual += temp*temp;
temp = work.KKT[1461]-work.L[687]*work.d[706]*1;
residual += temp*temp;
temp = work.KKT[1465]-1*work.d[708]*work.L[1413]-work.L[688]*work.d[707]*work.L[1412];
residual += temp*temp;
temp = work.KKT[1467]-1*work.d[709]*work.L[690];
residual += temp*temp;
temp = work.KKT[1468]-work.L[692]*work.d[710]*1;
residual += temp*temp;
temp = work.KKT[1471]-1*work.d[711]*work.L[1446];
residual += temp*temp;
temp = work.KKT[1469]-work.L[694]*work.d[710]*1;
residual += temp*temp;
temp = work.KKT[1473]-1*work.d[712]*work.L[1447]-work.L[695]*work.d[711]*work.L[1446];
residual += temp*temp;
temp = work.KKT[1475]-1*work.d[713]*work.L[697];
residual += temp*temp;
temp = work.KKT[1476]-work.L[699]*work.d[714]*1;
residual += temp*temp;
temp = work.KKT[1479]-1*work.d[715]*work.L[1480];
residual += temp*temp;
temp = work.KKT[1477]-work.L[701]*work.d[714]*1;
residual += temp*temp;
temp = work.KKT[1481]-1*work.d[716]*work.L[1481]-work.L[702]*work.d[715]*work.L[1480];
residual += temp*temp;
temp = work.KKT[1483]-1*work.d[717]*work.L[704];
residual += temp*temp;
temp = work.KKT[1484]-work.L[706]*work.d[718]*1;
residual += temp*temp;
temp = work.KKT[1487]-1*work.d[719]*work.L[1547];
residual += temp*temp;
temp = work.KKT[1485]-work.L[708]*work.d[718]*1;
residual += temp*temp;
temp = work.KKT[1489]-1*work.d[720]*work.L[1548]-work.L[709]*work.d[719]*work.L[1547];
residual += temp*temp;
temp = work.KKT[1491]-1*work.d[721]*work.L[711];
residual += temp*temp;
temp = work.KKT[1492]-work.L[713]*work.d[722]*1;
residual += temp*temp;
temp = work.KKT[1495]-1*work.d[723]*work.L[1506];
residual += temp*temp;
temp = work.KKT[1493]-work.L[715]*work.d[722]*1;
residual += temp*temp;
temp = work.KKT[1497]-1*work.d[724]*work.L[1507]-work.L[716]*work.d[723]*work.L[1506];
residual += temp*temp;
temp = work.KKT[1499]-1*work.d[725]*work.L[718];
residual += temp*temp;
temp = work.KKT[1500]-work.L[720]*work.d[726]*1;
residual += temp*temp;
temp = work.KKT[1503]-1*work.d[727]*work.L[778];
residual += temp*temp;
temp = work.KKT[1501]-work.L[722]*work.d[726]*1;
residual += temp*temp;
temp = work.KKT[1505]-1*work.d[728]*work.L[779]-work.L[723]*work.d[727]*work.L[778];
residual += temp*temp;
temp = work.KKT[1507]-1*work.d[729]*work.L[725];
residual += temp*temp;
temp = work.KKT[1508]-work.L[727]*work.d[730]*1;
residual += temp*temp;
temp = work.KKT[1511]-1*work.d[731]*work.L[731];
residual += temp*temp;
temp = work.KKT[1509]-work.L[729]*work.d[730]*1;
residual += temp*temp;
temp = work.KKT[1513]-1*work.d[732]*work.L[732]-work.L[730]*work.d[731]*work.L[731];
residual += temp*temp;
temp = work.KKT[1517]-1*work.d[735]*work.L[743];
residual += temp*temp;
temp = work.KKT[624]-1*work.d[312]*work.L[0];
residual += temp*temp;
temp = work.KKT[625]-1*work.d[313]*work.L[749];
residual += temp*temp;
temp = work.KKT[1518]-1*work.d[735]*work.L[792];
residual += temp*temp;
temp = work.KKT[1600]-1*work.d[767]*work.L[765];
residual += temp*temp;
temp = work.KKT[627]-work.L[744]*work.d[314]*1;
residual += temp*temp;
temp = work.KKT[1527]-work.L[756]*work.d[741]*1;
residual += temp*temp;
temp = work.KKT[1601]-1*work.d[767]*work.L[795];
residual += temp*temp;
temp = work.KKT[1519]-1*work.d[737]*work.L[752];
residual += temp*temp;
temp = work.KKT[1599]-1*work.d[766]*work.L[794];
residual += temp*temp;
temp = work.KKT[1520]-1*work.d[737]*work.L[753];
residual += temp*temp;
temp = work.KKT[1598]-1*work.d[766]*work.L[788];
residual += temp*temp;
temp = work.KKT[1602]-1*work.d[767]*work.L[801];
residual += temp*temp;
temp = work.KKT[1605]-1*work.d[770]*work.L[827];
residual += temp*temp;
temp = work.KKT[1529]-work.L[766]*work.d[742]*1;
residual += temp*temp;
temp = work.KKT[1619]-work.L[805]*work.d[777]*1;
residual += temp*temp;
temp = work.KKT[1604]-1*work.d[770]*work.L[803];
residual += temp*temp;
temp = work.KKT[1603]-1*work.d[769]*work.L[789]-work.L[768]*work.d[766]*work.L[788];
residual += temp*temp;
temp = work.KKT[1622]-work.L[807]*work.d[779]*1-work.L[806]*work.d[778]*work.L[804];
residual += temp*temp;
temp = work.KKT[1531]-work.L[767]*work.d[743]*1;
residual += temp*temp;
temp = work.KKT[1623]-1*work.d[780]*work.L[810];
residual += temp*temp;
temp = work.KKT[1606]-1*work.d[770]*work.L[835];
residual += temp*temp;
temp = work.KKT[1630]-1*work.d[785]*work.L[864];
residual += temp*temp;
temp = work.KKT[1532]-work.L[812]*work.d[743]*1;
residual += temp*temp;
temp = work.KKT[1624]-1*work.d[781]*work.L[811];
residual += temp*temp;
temp = work.KKT[1629]-1*work.d[785]*work.L[842];
residual += temp*temp;
temp = work.KKT[1628]-work.L[819]*work.d[782]*1-work.L[818]*work.d[780]*work.L[810];
residual += temp*temp;
temp = work.KKT[1625]-1*work.d[781]*work.L[838];
residual += temp*temp;
temp = work.KKT[1534]-work.L[813]*work.d[744]*1;
residual += temp*temp;
temp = work.KKT[1626]-1*work.d[781]*work.L[845];
residual += temp*temp;
temp = work.KKT[1631]-1*work.d[785]*work.L[870];
residual += temp*temp;
temp = work.KKT[1639]-1*work.d[791]*work.L[898];
residual += temp*temp;
temp = work.KKT[1535]-work.L[851]*work.d[744]*1;
residual += temp*temp;
temp = work.KKT[1633]-1*work.d[787]*work.L[850];
residual += temp*temp;
temp = work.KKT[1638]-1*work.d[791]*work.L[876];
residual += temp*temp;
temp = work.KKT[1637]-work.L[856]*work.d[788]*1-work.L[853]*work.d[783]*work.L[847]-work.L[854]*work.d[784]*work.L[848]-work.L[855]*work.d[786]*work.L[849];
residual += temp*temp;
temp = work.KKT[1634]-1*work.d[787]*work.L[872];
residual += temp*temp;
temp = work.KKT[1537]-work.L[852]*work.d[745]*1;
residual += temp*temp;
temp = work.KKT[1635]-1*work.d[787]*work.L[879];
residual += temp*temp;
temp = work.KKT[1640]-1*work.d[791]*work.L[904];
residual += temp*temp;
temp = work.KKT[1648]-1*work.d[797]*work.L[932];
residual += temp*temp;
temp = work.KKT[1538]-work.L[885]*work.d[745]*1;
residual += temp*temp;
temp = work.KKT[1642]-1*work.d[793]*work.L[884];
residual += temp*temp;
temp = work.KKT[1647]-1*work.d[797]*work.L[910];
residual += temp*temp;
temp = work.KKT[1646]-work.L[890]*work.d[794]*1-work.L[887]*work.d[789]*work.L[881]-work.L[888]*work.d[790]*work.L[882]-work.L[889]*work.d[792]*work.L[883];
residual += temp*temp;
temp = work.KKT[1643]-1*work.d[793]*work.L[906];
residual += temp*temp;
temp = work.KKT[1540]-work.L[886]*work.d[746]*1;
residual += temp*temp;
temp = work.KKT[1644]-1*work.d[793]*work.L[913];
residual += temp*temp;
temp = work.KKT[1649]-1*work.d[797]*work.L[938];
residual += temp*temp;
temp = work.KKT[1657]-1*work.d[803]*work.L[966];
residual += temp*temp;
temp = work.KKT[1541]-work.L[919]*work.d[746]*1;
residual += temp*temp;
temp = work.KKT[1651]-1*work.d[799]*work.L[918];
residual += temp*temp;
temp = work.KKT[1656]-1*work.d[803]*work.L[944];
residual += temp*temp;
temp = work.KKT[1655]-work.L[924]*work.d[800]*1-work.L[921]*work.d[795]*work.L[915]-work.L[922]*work.d[796]*work.L[916]-work.L[923]*work.d[798]*work.L[917];
residual += temp*temp;
temp = work.KKT[1652]-1*work.d[799]*work.L[940];
residual += temp*temp;
temp = work.KKT[1543]-work.L[920]*work.d[747]*1;
residual += temp*temp;
temp = work.KKT[1653]-1*work.d[799]*work.L[947];
residual += temp*temp;
temp = work.KKT[1658]-1*work.d[803]*work.L[972];
residual += temp*temp;
temp = work.KKT[1666]-1*work.d[809]*work.L[1000];
residual += temp*temp;
temp = work.KKT[1544]-work.L[953]*work.d[747]*1;
residual += temp*temp;
temp = work.KKT[1660]-1*work.d[805]*work.L[952];
residual += temp*temp;
temp = work.KKT[1665]-1*work.d[809]*work.L[978];
residual += temp*temp;
temp = work.KKT[1664]-work.L[958]*work.d[806]*1-work.L[955]*work.d[801]*work.L[949]-work.L[956]*work.d[802]*work.L[950]-work.L[957]*work.d[804]*work.L[951];
residual += temp*temp;
temp = work.KKT[1661]-1*work.d[805]*work.L[974];
residual += temp*temp;
temp = work.KKT[1546]-work.L[954]*work.d[748]*1;
residual += temp*temp;
temp = work.KKT[1662]-1*work.d[805]*work.L[981];
residual += temp*temp;
temp = work.KKT[1667]-1*work.d[809]*work.L[1006];
residual += temp*temp;
temp = work.KKT[1675]-1*work.d[815]*work.L[1034];
residual += temp*temp;
temp = work.KKT[1547]-work.L[987]*work.d[748]*1;
residual += temp*temp;
temp = work.KKT[1669]-1*work.d[811]*work.L[986];
residual += temp*temp;
temp = work.KKT[1674]-1*work.d[815]*work.L[1012];
residual += temp*temp;
temp = work.KKT[1673]-work.L[992]*work.d[812]*1-work.L[989]*work.d[807]*work.L[983]-work.L[990]*work.d[808]*work.L[984]-work.L[991]*work.d[810]*work.L[985];
residual += temp*temp;
temp = work.KKT[1670]-1*work.d[811]*work.L[1008];
residual += temp*temp;
temp = work.KKT[1549]-work.L[988]*work.d[749]*1;
residual += temp*temp;
temp = work.KKT[1671]-1*work.d[811]*work.L[1015];
residual += temp*temp;
temp = work.KKT[1676]-1*work.d[815]*work.L[1040];
residual += temp*temp;
temp = work.KKT[1684]-1*work.d[821]*work.L[1068];
residual += temp*temp;
temp = work.KKT[1550]-work.L[1021]*work.d[749]*1;
residual += temp*temp;
temp = work.KKT[1678]-1*work.d[817]*work.L[1020];
residual += temp*temp;
temp = work.KKT[1683]-1*work.d[821]*work.L[1046];
residual += temp*temp;
temp = work.KKT[1682]-work.L[1026]*work.d[818]*1-work.L[1023]*work.d[813]*work.L[1017]-work.L[1024]*work.d[814]*work.L[1018]-work.L[1025]*work.d[816]*work.L[1019];
residual += temp*temp;
temp = work.KKT[1679]-1*work.d[817]*work.L[1042];
residual += temp*temp;
temp = work.KKT[1552]-work.L[1022]*work.d[750]*1;
residual += temp*temp;
temp = work.KKT[1680]-1*work.d[817]*work.L[1049];
residual += temp*temp;
temp = work.KKT[1685]-1*work.d[821]*work.L[1074];
residual += temp*temp;
temp = work.KKT[1693]-1*work.d[827]*work.L[1102];
residual += temp*temp;
temp = work.KKT[1553]-work.L[1055]*work.d[750]*1;
residual += temp*temp;
temp = work.KKT[1687]-1*work.d[823]*work.L[1054];
residual += temp*temp;
temp = work.KKT[1692]-1*work.d[827]*work.L[1080];
residual += temp*temp;
temp = work.KKT[1691]-work.L[1060]*work.d[824]*1-work.L[1057]*work.d[819]*work.L[1051]-work.L[1058]*work.d[820]*work.L[1052]-work.L[1059]*work.d[822]*work.L[1053];
residual += temp*temp;
temp = work.KKT[1688]-1*work.d[823]*work.L[1076];
residual += temp*temp;
temp = work.KKT[1555]-work.L[1056]*work.d[751]*1;
residual += temp*temp;
temp = work.KKT[1689]-1*work.d[823]*work.L[1083];
residual += temp*temp;
temp = work.KKT[1694]-1*work.d[827]*work.L[1108];
residual += temp*temp;
temp = work.KKT[1702]-1*work.d[833]*work.L[1136];
residual += temp*temp;
temp = work.KKT[1556]-work.L[1089]*work.d[751]*1;
residual += temp*temp;
temp = work.KKT[1696]-1*work.d[829]*work.L[1088];
residual += temp*temp;
temp = work.KKT[1701]-1*work.d[833]*work.L[1114];
residual += temp*temp;
temp = work.KKT[1700]-work.L[1094]*work.d[830]*1-work.L[1091]*work.d[825]*work.L[1085]-work.L[1092]*work.d[826]*work.L[1086]-work.L[1093]*work.d[828]*work.L[1087];
residual += temp*temp;
temp = work.KKT[1697]-1*work.d[829]*work.L[1110];
residual += temp*temp;
temp = work.KKT[1558]-work.L[1090]*work.d[752]*1;
residual += temp*temp;
temp = work.KKT[1698]-1*work.d[829]*work.L[1117];
residual += temp*temp;
temp = work.KKT[1703]-1*work.d[833]*work.L[1142];
residual += temp*temp;
temp = work.KKT[1711]-1*work.d[839]*work.L[1170];
residual += temp*temp;
temp = work.KKT[1559]-work.L[1123]*work.d[752]*1;
residual += temp*temp;
temp = work.KKT[1705]-1*work.d[835]*work.L[1122];
residual += temp*temp;
temp = work.KKT[1710]-1*work.d[839]*work.L[1148];
residual += temp*temp;
temp = work.KKT[1709]-work.L[1128]*work.d[836]*1-work.L[1125]*work.d[831]*work.L[1119]-work.L[1126]*work.d[832]*work.L[1120]-work.L[1127]*work.d[834]*work.L[1121];
residual += temp*temp;
temp = work.KKT[1706]-1*work.d[835]*work.L[1144];
residual += temp*temp;
temp = work.KKT[1561]-work.L[1124]*work.d[753]*1;
residual += temp*temp;
temp = work.KKT[1707]-1*work.d[835]*work.L[1151];
residual += temp*temp;
temp = work.KKT[1712]-1*work.d[839]*work.L[1176];
residual += temp*temp;
temp = work.KKT[1720]-1*work.d[845]*work.L[1204];
residual += temp*temp;
temp = work.KKT[1562]-work.L[1157]*work.d[753]*1;
residual += temp*temp;
temp = work.KKT[1714]-1*work.d[841]*work.L[1156];
residual += temp*temp;
temp = work.KKT[1719]-1*work.d[845]*work.L[1182];
residual += temp*temp;
temp = work.KKT[1718]-work.L[1162]*work.d[842]*1-work.L[1159]*work.d[837]*work.L[1153]-work.L[1160]*work.d[838]*work.L[1154]-work.L[1161]*work.d[840]*work.L[1155];
residual += temp*temp;
temp = work.KKT[1715]-1*work.d[841]*work.L[1178];
residual += temp*temp;
temp = work.KKT[1564]-work.L[1158]*work.d[754]*1;
residual += temp*temp;
temp = work.KKT[1716]-1*work.d[841]*work.L[1185];
residual += temp*temp;
temp = work.KKT[1721]-1*work.d[845]*work.L[1210];
residual += temp*temp;
temp = work.KKT[1729]-1*work.d[851]*work.L[1238];
residual += temp*temp;
temp = work.KKT[1565]-work.L[1191]*work.d[754]*1;
residual += temp*temp;
temp = work.KKT[1723]-1*work.d[847]*work.L[1190];
residual += temp*temp;
temp = work.KKT[1728]-1*work.d[851]*work.L[1216];
residual += temp*temp;
temp = work.KKT[1727]-work.L[1196]*work.d[848]*1-work.L[1193]*work.d[843]*work.L[1187]-work.L[1194]*work.d[844]*work.L[1188]-work.L[1195]*work.d[846]*work.L[1189];
residual += temp*temp;
temp = work.KKT[1724]-1*work.d[847]*work.L[1212];
residual += temp*temp;
temp = work.KKT[1567]-work.L[1192]*work.d[755]*1;
residual += temp*temp;
temp = work.KKT[1725]-1*work.d[847]*work.L[1219];
residual += temp*temp;
temp = work.KKT[1730]-1*work.d[851]*work.L[1244];
residual += temp*temp;
temp = work.KKT[1738]-1*work.d[857]*work.L[1272];
residual += temp*temp;
temp = work.KKT[1568]-work.L[1225]*work.d[755]*1;
residual += temp*temp;
temp = work.KKT[1732]-1*work.d[853]*work.L[1224];
residual += temp*temp;
temp = work.KKT[1737]-1*work.d[857]*work.L[1250];
residual += temp*temp;
temp = work.KKT[1736]-work.L[1230]*work.d[854]*1-work.L[1227]*work.d[849]*work.L[1221]-work.L[1228]*work.d[850]*work.L[1222]-work.L[1229]*work.d[852]*work.L[1223];
residual += temp*temp;
temp = work.KKT[1733]-1*work.d[853]*work.L[1246];
residual += temp*temp;
temp = work.KKT[1570]-work.L[1226]*work.d[756]*1;
residual += temp*temp;
temp = work.KKT[1734]-1*work.d[853]*work.L[1253];
residual += temp*temp;
temp = work.KKT[1739]-1*work.d[857]*work.L[1278];
residual += temp*temp;
temp = work.KKT[1747]-1*work.d[863]*work.L[1306];
residual += temp*temp;
temp = work.KKT[1571]-work.L[1259]*work.d[756]*1;
residual += temp*temp;
temp = work.KKT[1741]-1*work.d[859]*work.L[1258];
residual += temp*temp;
temp = work.KKT[1746]-1*work.d[863]*work.L[1284];
residual += temp*temp;
temp = work.KKT[1745]-work.L[1264]*work.d[860]*1-work.L[1261]*work.d[855]*work.L[1255]-work.L[1262]*work.d[856]*work.L[1256]-work.L[1263]*work.d[858]*work.L[1257];
residual += temp*temp;
temp = work.KKT[1742]-1*work.d[859]*work.L[1280];
residual += temp*temp;
temp = work.KKT[1573]-work.L[1260]*work.d[757]*1;
residual += temp*temp;
temp = work.KKT[1743]-1*work.d[859]*work.L[1287];
residual += temp*temp;
temp = work.KKT[1748]-1*work.d[863]*work.L[1312];
residual += temp*temp;
temp = work.KKT[1756]-1*work.d[869]*work.L[1340];
residual += temp*temp;
temp = work.KKT[1574]-work.L[1293]*work.d[757]*1;
residual += temp*temp;
temp = work.KKT[1750]-1*work.d[865]*work.L[1292];
residual += temp*temp;
temp = work.KKT[1755]-1*work.d[869]*work.L[1318];
residual += temp*temp;
temp = work.KKT[1754]-work.L[1298]*work.d[866]*1-work.L[1295]*work.d[861]*work.L[1289]-work.L[1296]*work.d[862]*work.L[1290]-work.L[1297]*work.d[864]*work.L[1291];
residual += temp*temp;
temp = work.KKT[1751]-1*work.d[865]*work.L[1314];
residual += temp*temp;
temp = work.KKT[1576]-work.L[1294]*work.d[758]*1;
residual += temp*temp;
temp = work.KKT[1752]-1*work.d[865]*work.L[1321];
residual += temp*temp;
temp = work.KKT[1757]-1*work.d[869]*work.L[1346];
residual += temp*temp;
temp = work.KKT[1765]-1*work.d[875]*work.L[1374];
residual += temp*temp;
temp = work.KKT[1577]-work.L[1327]*work.d[758]*1;
residual += temp*temp;
temp = work.KKT[1759]-1*work.d[871]*work.L[1326];
residual += temp*temp;
temp = work.KKT[1764]-1*work.d[875]*work.L[1352];
residual += temp*temp;
temp = work.KKT[1763]-work.L[1332]*work.d[872]*1-work.L[1329]*work.d[867]*work.L[1323]-work.L[1330]*work.d[868]*work.L[1324]-work.L[1331]*work.d[870]*work.L[1325];
residual += temp*temp;
temp = work.KKT[1760]-1*work.d[871]*work.L[1348];
residual += temp*temp;
temp = work.KKT[1579]-work.L[1328]*work.d[759]*1;
residual += temp*temp;
temp = work.KKT[1761]-1*work.d[871]*work.L[1355];
residual += temp*temp;
temp = work.KKT[1766]-1*work.d[875]*work.L[1380];
residual += temp*temp;
temp = work.KKT[1774]-1*work.d[881]*work.L[1408];
residual += temp*temp;
temp = work.KKT[1580]-work.L[1361]*work.d[759]*1;
residual += temp*temp;
temp = work.KKT[1768]-1*work.d[877]*work.L[1360];
residual += temp*temp;
temp = work.KKT[1773]-1*work.d[881]*work.L[1386];
residual += temp*temp;
temp = work.KKT[1772]-work.L[1366]*work.d[878]*1-work.L[1363]*work.d[873]*work.L[1357]-work.L[1364]*work.d[874]*work.L[1358]-work.L[1365]*work.d[876]*work.L[1359];
residual += temp*temp;
temp = work.KKT[1769]-1*work.d[877]*work.L[1382];
residual += temp*temp;
temp = work.KKT[1582]-work.L[1362]*work.d[760]*1;
residual += temp*temp;
temp = work.KKT[1770]-1*work.d[877]*work.L[1389];
residual += temp*temp;
temp = work.KKT[1775]-1*work.d[881]*work.L[1414];
residual += temp*temp;
temp = work.KKT[1783]-1*work.d[887]*work.L[1442];
residual += temp*temp;
temp = work.KKT[1583]-work.L[1395]*work.d[760]*1;
residual += temp*temp;
temp = work.KKT[1777]-1*work.d[883]*work.L[1394];
residual += temp*temp;
temp = work.KKT[1782]-1*work.d[887]*work.L[1420];
residual += temp*temp;
temp = work.KKT[1781]-work.L[1400]*work.d[884]*1-work.L[1397]*work.d[879]*work.L[1391]-work.L[1398]*work.d[880]*work.L[1392]-work.L[1399]*work.d[882]*work.L[1393];
residual += temp*temp;
temp = work.KKT[1778]-1*work.d[883]*work.L[1416];
residual += temp*temp;
temp = work.KKT[1585]-work.L[1396]*work.d[761]*1;
residual += temp*temp;
temp = work.KKT[1779]-1*work.d[883]*work.L[1423];
residual += temp*temp;
temp = work.KKT[1784]-1*work.d[887]*work.L[1448];
residual += temp*temp;
temp = work.KKT[1792]-1*work.d[893]*work.L[1476];
residual += temp*temp;
temp = work.KKT[1586]-work.L[1429]*work.d[761]*1;
residual += temp*temp;
temp = work.KKT[1786]-1*work.d[889]*work.L[1428];
residual += temp*temp;
temp = work.KKT[1791]-1*work.d[893]*work.L[1454];
residual += temp*temp;
temp = work.KKT[1790]-work.L[1434]*work.d[890]*1-work.L[1431]*work.d[885]*work.L[1425]-work.L[1432]*work.d[886]*work.L[1426]-work.L[1433]*work.d[888]*work.L[1427];
residual += temp*temp;
temp = work.KKT[1787]-1*work.d[889]*work.L[1450];
residual += temp*temp;
temp = work.KKT[1588]-work.L[1430]*work.d[762]*1;
residual += temp*temp;
temp = work.KKT[1788]-1*work.d[889]*work.L[1457];
residual += temp*temp;
temp = work.KKT[1793]-1*work.d[893]*work.L[1482];
residual += temp*temp;
temp = work.KKT[1801]-1*work.d[899]*work.L[1496];
residual += temp*temp;
temp = work.KKT[1589]-work.L[1463]*work.d[762]*1;
residual += temp*temp;
temp = work.KKT[1795]-1*work.d[895]*work.L[1462];
residual += temp*temp;
temp = work.KKT[1800]-1*work.d[899]*work.L[1488];
residual += temp*temp;
temp = work.KKT[1799]-work.L[1468]*work.d[896]*1-work.L[1465]*work.d[891]*work.L[1459]-work.L[1466]*work.d[892]*work.L[1460]-work.L[1467]*work.d[894]*work.L[1461];
residual += temp*temp;
temp = work.KKT[1796]-1*work.d[895]*work.L[1484];
residual += temp*temp;
temp = work.KKT[1591]-work.L[1464]*work.d[763]*1;
residual += temp*temp;
temp = work.KKT[1797]-1*work.d[895]*work.L[1538];
residual += temp*temp;
temp = work.KKT[1802]-1*work.d[899]*work.L[1550];
residual += temp*temp;
temp = work.KKT[1612]-1*work.d[774]*work.L[1522];
residual += temp*temp;
temp = work.KKT[1592]-work.L[1526]*work.d[763]*1;
residual += temp*temp;
temp = work.KKT[1807]-1*work.d[906]*work.L[1546];
residual += temp*temp;
temp = work.KKT[1613]-1*work.d[774]*work.L[1549];
residual += temp*temp;
temp = work.KKT[1806]-work.L[1529]*work.d[897]*work.L[1540]-1*work.d[905]*work.L[1545]-work.L[1530]*work.d[898]*work.L[1541]-work.L[1531]*work.d[900]*work.L[1542]-work.L[1532]*work.d[901]*work.L[1543]-work.L[1535]*work.d[904]*work.L[1544];
residual += temp*temp;
temp = work.KKT[1808]-1*work.d[906]*work.L[1556];
residual += temp*temp;
temp = work.KKT[1595]-work.L[1527]*work.d[764]*1;
residual += temp*temp;
temp = work.KKT[1809]-1*work.d[906]*work.L[1566];
residual += temp*temp;
temp = work.KKT[1611]-1*work.d[774]*work.L[1511];
residual += temp*temp;
temp = work.KKT[1607]-1*work.d[771]*work.L[777];
residual += temp*temp;
temp = work.KKT[1594]-work.L[784]*work.d[764]*1;
residual += temp*temp;
temp = work.KKT[1616]-1*work.d[775]*work.L[1560];
residual += temp*temp;
temp = work.KKT[1609]-1*work.d[771]*work.L[1508];
residual += temp*temp;
temp = work.KKT[1617]-1*work.d[776]*work.L[1561];
residual += temp*temp;
temp = work.KKT[1615]-1*work.d[775]*work.L[1512];
residual += temp*temp;
temp = work.KKT[1597]-work.L[785]*work.d[765]*1;
residual += temp*temp;
temp = work.KKT[1614]-1*work.d[775]*work.L[1504];
residual += temp*temp;
temp = work.KKT[1608]-1*work.d[771]*work.L[782];
residual += temp*temp;
temp = work.KKT[1516]-work.L[748]*work.d[734]*1;
residual += temp*temp;
temp = work.KKT[1521]-1*work.d[738]*work.L[755];
residual += temp*temp;
temp = work.KKT[1524]-1*work.d[739]*work.L[1501];
residual += temp*temp;
temp = work.KKT[1525]-1*work.d[740]*work.L[781];
residual += temp*temp;
temp = work.KKT[1522]-1*work.d[738]*work.L[1500];
residual += temp*temp;
temp = work.KKT[1523]-1*work.d[739]*work.L[780];
residual += temp*temp;
temp = work.KKT[629]-work.L[745]*work.d[315]*1;
residual += temp*temp;
temp = work.KKT[1305]-work.L[746]*work.d[628]*1;
residual += temp*temp;
temp = work.KKT[1515]-work.L[747]*work.d[733]*1;
residual += temp*temp;
return residual;
}
void matrix_multiply(double *result, double *source) {
/* Finds result = A*source. */
result[0] = work.KKT[631]*source[520]+work.KKT[632]*source[521]+work.KKT[633]*source[522];
result[1] = work.KKT[639]*source[523]+work.KKT[640]*source[524]+work.KKT[641]*source[525];
result[2] = work.KKT[647]*source[526]+work.KKT[648]*source[527]+work.KKT[649]*source[528];
result[3] = work.KKT[655]*source[529]+work.KKT[656]*source[530]+work.KKT[657]*source[531];
result[4] = work.KKT[663]*source[532]+work.KKT[664]*source[533]+work.KKT[665]*source[534];
result[5] = work.KKT[671]*source[535]+work.KKT[672]*source[536]+work.KKT[673]*source[537];
result[6] = work.KKT[679]*source[538]+work.KKT[680]*source[539]+work.KKT[681]*source[540];
result[7] = work.KKT[687]*source[541]+work.KKT[688]*source[542]+work.KKT[689]*source[543];
result[8] = work.KKT[695]*source[544]+work.KKT[696]*source[545]+work.KKT[697]*source[546];
result[9] = work.KKT[703]*source[547]+work.KKT[704]*source[548]+work.KKT[705]*source[549];
result[10] = work.KKT[711]*source[550]+work.KKT[712]*source[551]+work.KKT[713]*source[552];
result[11] = work.KKT[719]*source[553]+work.KKT[720]*source[554]+work.KKT[721]*source[555];
result[12] = work.KKT[727]*source[556]+work.KKT[728]*source[557]+work.KKT[729]*source[558];
result[13] = work.KKT[735]*source[559]+work.KKT[736]*source[560]+work.KKT[737]*source[561];
result[14] = work.KKT[743]*source[562]+work.KKT[744]*source[563]+work.KKT[745]*source[564];
result[15] = work.KKT[751]*source[565]+work.KKT[752]*source[566]+work.KKT[753]*source[567];
result[16] = work.KKT[759]*source[568]+work.KKT[760]*source[569]+work.KKT[761]*source[570];
result[17] = work.KKT[767]*source[571]+work.KKT[768]*source[572]+work.KKT[769]*source[573];
result[18] = work.KKT[775]*source[574]+work.KKT[776]*source[575]+work.KKT[777]*source[576];
result[19] = work.KKT[783]*source[577]+work.KKT[784]*source[578]+work.KKT[785]*source[579];
result[20] = work.KKT[791]*source[580]+work.KKT[792]*source[581]+work.KKT[793]*source[582];
result[21] = work.KKT[799]*source[583]+work.KKT[800]*source[584]+work.KKT[801]*source[585];
result[22] = work.KKT[807]*source[586]+work.KKT[808]*source[587]+work.KKT[809]*source[588];
result[23] = work.KKT[815]*source[589]+work.KKT[816]*source[590]+work.KKT[817]*source[591];
result[24] = work.KKT[823]*source[592]+work.KKT[824]*source[593]+work.KKT[825]*source[594];
result[25] = work.KKT[831]*source[595]+work.KKT[832]*source[596]+work.KKT[833]*source[597];
result[26] = work.KKT[839]*source[598]+work.KKT[840]*source[599]+work.KKT[841]*source[600];
result[27] = work.KKT[847]*source[601]+work.KKT[848]*source[602]+work.KKT[849]*source[603];
result[28] = work.KKT[857]*source[604]+work.KKT[858]*source[605]+work.KKT[859]*source[606];
result[29] = work.KKT[867]*source[607]+work.KKT[868]*source[608]+work.KKT[869]*source[609];
result[30] = work.KKT[877]*source[610]+work.KKT[878]*source[611]+work.KKT[879]*source[612];
result[31] = work.KKT[887]*source[613]+work.KKT[888]*source[614]+work.KKT[889]*source[615];
result[32] = work.KKT[897]*source[616]+work.KKT[898]*source[617]+work.KKT[899]*source[618];
result[33] = work.KKT[907]*source[619]+work.KKT[908]*source[620]+work.KKT[909]*source[621];
result[34] = work.KKT[917]*source[622]+work.KKT[918]*source[623]+work.KKT[919]*source[624];
result[35] = work.KKT[927]*source[625]+work.KKT[928]*source[626]+work.KKT[929]*source[627];
result[36] = work.KKT[937]*source[628]+work.KKT[938]*source[629]+work.KKT[939]*source[630];
result[37] = work.KKT[947]*source[631]+work.KKT[948]*source[632]+work.KKT[949]*source[633];
result[38] = work.KKT[957]*source[634]+work.KKT[958]*source[635]+work.KKT[959]*source[636];
result[39] = work.KKT[967]*source[637]+work.KKT[968]*source[638]+work.KKT[969]*source[639];
result[40] = work.KKT[977]*source[640]+work.KKT[978]*source[641]+work.KKT[979]*source[642];
result[41] = work.KKT[987]*source[643]+work.KKT[988]*source[644]+work.KKT[989]*source[645];
result[42] = work.KKT[997]*source[646]+work.KKT[998]*source[647]+work.KKT[999]*source[648];
result[43] = work.KKT[1007]*source[649]+work.KKT[1008]*source[650]+work.KKT[1009]*source[651];
result[44] = work.KKT[1017]*source[652]+work.KKT[1018]*source[653]+work.KKT[1019]*source[654];
result[45] = work.KKT[1027]*source[655]+work.KKT[1028]*source[656]+work.KKT[1029]*source[657];
result[46] = work.KKT[1037]*source[658]+work.KKT[1038]*source[659]+work.KKT[1039]*source[660];
result[47] = work.KKT[1047]*source[661]+work.KKT[1048]*source[662]+work.KKT[1049]*source[663];
result[48] = work.KKT[1057]*source[664]+work.KKT[1058]*source[665]+work.KKT[1059]*source[666];
result[49] = work.KKT[1067]*source[667]+work.KKT[1068]*source[668]+work.KKT[1069]*source[669];
result[50] = work.KKT[1077]*source[670]+work.KKT[1078]*source[671]+work.KKT[1079]*source[672];
result[51] = work.KKT[1087]*source[673]+work.KKT[1088]*source[674]+work.KKT[1089]*source[675];
result[52] = work.KKT[1097]*source[676]+work.KKT[1098]*source[677]+work.KKT[1099]*source[678];
result[53] = work.KKT[1105]*source[679]+work.KKT[1106]*source[680]+work.KKT[1107]*source[681];
result[54] = work.KKT[1113]*source[682]+work.KKT[1114]*source[683]+work.KKT[1115]*source[684];
result[55] = work.KKT[1121]*source[685]+work.KKT[1122]*source[686]+work.KKT[1123]*source[687];
result[56] = work.KKT[1129]*source[688]+work.KKT[1130]*source[689]+work.KKT[1131]*source[690];
result[57] = work.KKT[1137]*source[691]+work.KKT[1138]*source[692]+work.KKT[1139]*source[693];
result[58] = work.KKT[1145]*source[694]+work.KKT[1146]*source[695]+work.KKT[1147]*source[696];
result[59] = work.KKT[1153]*source[697]+work.KKT[1154]*source[698]+work.KKT[1155]*source[699];
result[60] = work.KKT[1161]*source[700]+work.KKT[1162]*source[701]+work.KKT[1163]*source[702];
result[61] = work.KKT[1169]*source[703]+work.KKT[1170]*source[704]+work.KKT[1171]*source[705];
result[62] = work.KKT[1177]*source[706]+work.KKT[1178]*source[707]+work.KKT[1179]*source[708];
result[63] = work.KKT[1185]*source[709]+work.KKT[1186]*source[710]+work.KKT[1187]*source[711];
result[64] = work.KKT[1193]*source[712]+work.KKT[1194]*source[713]+work.KKT[1195]*source[714];
result[65] = work.KKT[1201]*source[715]+work.KKT[1202]*source[716]+work.KKT[1203]*source[717];
result[66] = work.KKT[1209]*source[718]+work.KKT[1210]*source[719]+work.KKT[1211]*source[720];
result[67] = work.KKT[1217]*source[721]+work.KKT[1218]*source[722]+work.KKT[1219]*source[723];
result[68] = work.KKT[1225]*source[724]+work.KKT[1226]*source[725]+work.KKT[1227]*source[726];
result[69] = work.KKT[1233]*source[727]+work.KKT[1234]*source[728]+work.KKT[1235]*source[729];
result[70] = work.KKT[1241]*source[730]+work.KKT[1242]*source[731]+work.KKT[1243]*source[732];
result[71] = work.KKT[1249]*source[733]+work.KKT[1250]*source[734]+work.KKT[1251]*source[735];
result[72] = work.KKT[1257]*source[736]+work.KKT[1258]*source[737]+work.KKT[1259]*source[738];
result[73] = work.KKT[1265]*source[739]+work.KKT[1266]*source[740]+work.KKT[1267]*source[741];
result[74] = work.KKT[1273]*source[742]+work.KKT[1274]*source[743]+work.KKT[1275]*source[744];
result[75] = work.KKT[1281]*source[745]+work.KKT[1282]*source[746]+work.KKT[1283]*source[747];
result[76] = work.KKT[1289]*source[748]+work.KKT[1290]*source[749]+work.KKT[1291]*source[750];
result[77] = work.KKT[1297]*source[751]+work.KKT[1298]*source[752]+work.KKT[1299]*source[753];
result[78] = work.KKT[1307]*source[754]+work.KKT[1308]*source[755]+work.KKT[1309]*source[756];
result[79] = work.KKT[1315]*source[757]+work.KKT[1316]*source[758]+work.KKT[1317]*source[759];
result[80] = work.KKT[1323]*source[760]+work.KKT[1324]*source[761]+work.KKT[1325]*source[762];
result[81] = work.KKT[1331]*source[763]+work.KKT[1332]*source[764]+work.KKT[1333]*source[765];
result[82] = work.KKT[1339]*source[766]+work.KKT[1340]*source[767]+work.KKT[1341]*source[768];
result[83] = work.KKT[1347]*source[769]+work.KKT[1348]*source[770]+work.KKT[1349]*source[771];
result[84] = work.KKT[1355]*source[772]+work.KKT[1356]*source[773]+work.KKT[1357]*source[774];
result[85] = work.KKT[1363]*source[775]+work.KKT[1364]*source[776]+work.KKT[1365]*source[777];
result[86] = work.KKT[1371]*source[778]+work.KKT[1372]*source[779]+work.KKT[1373]*source[780];
result[87] = work.KKT[1379]*source[781]+work.KKT[1380]*source[782]+work.KKT[1381]*source[783];
result[88] = work.KKT[1387]*source[784]+work.KKT[1388]*source[785]+work.KKT[1389]*source[786];
result[89] = work.KKT[1395]*source[787]+work.KKT[1396]*source[788]+work.KKT[1397]*source[789];
result[90] = work.KKT[1403]*source[790]+work.KKT[1404]*source[791]+work.KKT[1405]*source[792];
result[91] = work.KKT[1411]*source[793]+work.KKT[1412]*source[794]+work.KKT[1413]*source[795];
result[92] = work.KKT[1419]*source[796]+work.KKT[1420]*source[797]+work.KKT[1421]*source[798];
result[93] = work.KKT[1427]*source[799]+work.KKT[1428]*source[800]+work.KKT[1429]*source[801];
result[94] = work.KKT[1435]*source[802]+work.KKT[1436]*source[803]+work.KKT[1437]*source[804];
result[95] = work.KKT[1443]*source[805]+work.KKT[1444]*source[806]+work.KKT[1445]*source[807];
result[96] = work.KKT[1451]*source[808]+work.KKT[1452]*source[809]+work.KKT[1453]*source[810];
result[97] = work.KKT[1459]*source[811]+work.KKT[1460]*source[812]+work.KKT[1461]*source[813];
result[98] = work.KKT[1467]*source[814]+work.KKT[1468]*source[815]+work.KKT[1469]*source[816];
result[99] = work.KKT[1475]*source[817]+work.KKT[1476]*source[818]+work.KKT[1477]*source[819];
result[100] = work.KKT[1483]*source[820]+work.KKT[1484]*source[821]+work.KKT[1485]*source[822];
result[101] = work.KKT[1491]*source[823]+work.KKT[1492]*source[824]+work.KKT[1493]*source[825];
result[102] = work.KKT[1499]*source[826]+work.KKT[1500]*source[827]+work.KKT[1501]*source[828];
result[103] = work.KKT[1507]*source[829]+work.KKT[1508]*source[830]+work.KKT[1509]*source[831];
result[104] = work.KKT[635]*source[521]+work.KKT[637]*source[522]+work.KKT[843]*source[599]+work.KKT[845]*source[600]+work.KKT[851]*source[602]+work.KKT[854]*source[603]+work.KKT[1517]*source[834];
result[105] = work.KKT[643]*source[524]+work.KKT[645]*source[525]+work.KKT[852]*source[602]+work.KKT[855]*source[603]+work.KKT[861]*source[605]+work.KKT[864]*source[606]+work.KKT[1600]*source[837];
result[106] = work.KKT[651]*source[527]+work.KKT[653]*source[528]+work.KKT[862]*source[605]+work.KKT[865]*source[606]+work.KKT[871]*source[608]+work.KKT[874]*source[609]+work.KKT[1605]*source[840];
result[107] = work.KKT[659]*source[530]+work.KKT[661]*source[531]+work.KKT[872]*source[608]+work.KKT[875]*source[609]+work.KKT[881]*source[611]+work.KKT[884]*source[612]+work.KKT[1630]*source[843];
result[108] = work.KKT[667]*source[533]+work.KKT[669]*source[534]+work.KKT[882]*source[611]+work.KKT[885]*source[612]+work.KKT[891]*source[614]+work.KKT[894]*source[615]+work.KKT[1639]*source[846];
result[109] = work.KKT[675]*source[536]+work.KKT[677]*source[537]+work.KKT[892]*source[614]+work.KKT[895]*source[615]+work.KKT[901]*source[617]+work.KKT[904]*source[618]+work.KKT[1648]*source[849];
result[110] = work.KKT[683]*source[539]+work.KKT[685]*source[540]+work.KKT[902]*source[617]+work.KKT[905]*source[618]+work.KKT[911]*source[620]+work.KKT[914]*source[621]+work.KKT[1657]*source[852];
result[111] = work.KKT[691]*source[542]+work.KKT[693]*source[543]+work.KKT[912]*source[620]+work.KKT[915]*source[621]+work.KKT[921]*source[623]+work.KKT[924]*source[624]+work.KKT[1666]*source[855];
result[112] = work.KKT[699]*source[545]+work.KKT[701]*source[546]+work.KKT[922]*source[623]+work.KKT[925]*source[624]+work.KKT[931]*source[626]+work.KKT[934]*source[627]+work.KKT[1675]*source[858];
result[113] = work.KKT[707]*source[548]+work.KKT[709]*source[549]+work.KKT[932]*source[626]+work.KKT[935]*source[627]+work.KKT[941]*source[629]+work.KKT[944]*source[630]+work.KKT[1684]*source[861];
result[114] = work.KKT[715]*source[551]+work.KKT[717]*source[552]+work.KKT[942]*source[629]+work.KKT[945]*source[630]+work.KKT[951]*source[632]+work.KKT[954]*source[633]+work.KKT[1693]*source[864];
result[115] = work.KKT[723]*source[554]+work.KKT[725]*source[555]+work.KKT[952]*source[632]+work.KKT[955]*source[633]+work.KKT[961]*source[635]+work.KKT[964]*source[636]+work.KKT[1702]*source[867];
result[116] = work.KKT[731]*source[557]+work.KKT[733]*source[558]+work.KKT[962]*source[635]+work.KKT[965]*source[636]+work.KKT[971]*source[638]+work.KKT[974]*source[639]+work.KKT[1711]*source[870];
result[117] = work.KKT[739]*source[560]+work.KKT[741]*source[561]+work.KKT[972]*source[638]+work.KKT[975]*source[639]+work.KKT[981]*source[641]+work.KKT[984]*source[642]+work.KKT[1720]*source[873];
result[118] = work.KKT[747]*source[563]+work.KKT[749]*source[564]+work.KKT[982]*source[641]+work.KKT[985]*source[642]+work.KKT[991]*source[644]+work.KKT[994]*source[645]+work.KKT[1729]*source[876];
result[119] = work.KKT[755]*source[566]+work.KKT[757]*source[567]+work.KKT[992]*source[644]+work.KKT[995]*source[645]+work.KKT[1001]*source[647]+work.KKT[1004]*source[648]+work.KKT[1738]*source[879];
result[120] = work.KKT[763]*source[569]+work.KKT[765]*source[570]+work.KKT[1002]*source[647]+work.KKT[1005]*source[648]+work.KKT[1011]*source[650]+work.KKT[1014]*source[651]+work.KKT[1747]*source[882];
result[121] = work.KKT[771]*source[572]+work.KKT[773]*source[573]+work.KKT[1012]*source[650]+work.KKT[1015]*source[651]+work.KKT[1021]*source[653]+work.KKT[1024]*source[654]+work.KKT[1756]*source[885];
result[122] = work.KKT[779]*source[575]+work.KKT[781]*source[576]+work.KKT[1022]*source[653]+work.KKT[1025]*source[654]+work.KKT[1031]*source[656]+work.KKT[1034]*source[657]+work.KKT[1765]*source[888];
result[123] = work.KKT[787]*source[578]+work.KKT[789]*source[579]+work.KKT[1032]*source[656]+work.KKT[1035]*source[657]+work.KKT[1041]*source[659]+work.KKT[1044]*source[660]+work.KKT[1774]*source[891];
result[124] = work.KKT[795]*source[581]+work.KKT[797]*source[582]+work.KKT[1042]*source[659]+work.KKT[1045]*source[660]+work.KKT[1051]*source[662]+work.KKT[1054]*source[663]+work.KKT[1783]*source[894];
result[125] = work.KKT[803]*source[584]+work.KKT[805]*source[585]+work.KKT[1052]*source[662]+work.KKT[1055]*source[663]+work.KKT[1061]*source[665]+work.KKT[1064]*source[666]+work.KKT[1792]*source[897];
result[126] = work.KKT[811]*source[587]+work.KKT[813]*source[588]+work.KKT[1062]*source[665]+work.KKT[1065]*source[666]+work.KKT[1071]*source[668]+work.KKT[1074]*source[669]+work.KKT[1801]*source[900];
result[127] = work.KKT[819]*source[590]+work.KKT[821]*source[591]+work.KKT[1072]*source[668]+work.KKT[1075]*source[669]+work.KKT[1082]*source[671]+work.KKT[1085]*source[672]+work.KKT[1612]*source[903];
result[128] = work.KKT[827]*source[593]+work.KKT[829]*source[594]+work.KKT[1081]*source[671]+work.KKT[1084]*source[672]+work.KKT[1092]*source[674]+work.KKT[1095]*source[675]+work.KKT[1607]*source[906];
result[129] = work.KKT[835]*source[596]+work.KKT[837]*source[597]+work.KKT[1091]*source[674]+work.KKT[1094]*source[675]+work.KKT[1516]*source[909];
result[130] = work.KKT[626]*source[130]+work.KKT[624]*source[832]+work.KKT[627]*source[835];
result[131] = work.KKT[1526]*source[131]+work.KKT[1101]*source[677]+work.KKT[1103]*source[678]+work.KKT[625]*source[833]+work.KKT[1527]*source[836]+work.KKT[1519]*source[835];
result[132] = work.KKT[1620]*source[132]+work.KKT[1311]*source[755]+work.KKT[1313]*source[756]+work.KKT[1518]*source[834]+work.KKT[1601]*source[837]+work.KKT[1599]*source[836];
result[133] = work.KKT[1528]*source[133]+work.KKT[1520]*source[835]+work.KKT[1529]*source[838];
result[134] = work.KKT[1618]*source[134]+work.KKT[1109]*source[680]+work.KKT[1111]*source[681]+work.KKT[1598]*source[836]+work.KKT[1619]*source[839]+work.KKT[1603]*source[838];
result[135] = work.KKT[1621]*source[135]+work.KKT[1319]*source[758]+work.KKT[1321]*source[759]+work.KKT[1602]*source[837]+work.KKT[1604]*source[840]+work.KKT[1622]*source[839];
result[136] = work.KKT[1530]*source[136]+work.KKT[1531]*source[838]+work.KKT[1532]*source[841];
result[137] = work.KKT[1627]*source[137]+work.KKT[1117]*source[683]+work.KKT[1119]*source[684]+work.KKT[1623]*source[839]+work.KKT[1624]*source[842]+work.KKT[1628]*source[841];
result[138] = work.KKT[1632]*source[138]+work.KKT[1327]*source[761]+work.KKT[1329]*source[762]+work.KKT[1606]*source[840]+work.KKT[1629]*source[843]+work.KKT[1625]*source[842];
result[139] = work.KKT[1533]*source[139]+work.KKT[1534]*source[841]+work.KKT[1535]*source[844];
result[140] = work.KKT[1636]*source[140]+work.KKT[1125]*source[686]+work.KKT[1127]*source[687]+work.KKT[1626]*source[842]+work.KKT[1633]*source[845]+work.KKT[1637]*source[844];
result[141] = work.KKT[1641]*source[141]+work.KKT[1335]*source[764]+work.KKT[1337]*source[765]+work.KKT[1631]*source[843]+work.KKT[1638]*source[846]+work.KKT[1634]*source[845];
result[142] = work.KKT[1536]*source[142]+work.KKT[1537]*source[844]+work.KKT[1538]*source[847];
result[143] = work.KKT[1645]*source[143]+work.KKT[1133]*source[689]+work.KKT[1135]*source[690]+work.KKT[1635]*source[845]+work.KKT[1642]*source[848]+work.KKT[1646]*source[847];
result[144] = work.KKT[1650]*source[144]+work.KKT[1343]*source[767]+work.KKT[1345]*source[768]+work.KKT[1640]*source[846]+work.KKT[1647]*source[849]+work.KKT[1643]*source[848];
result[145] = work.KKT[1539]*source[145]+work.KKT[1540]*source[847]+work.KKT[1541]*source[850];
result[146] = work.KKT[1654]*source[146]+work.KKT[1141]*source[692]+work.KKT[1143]*source[693]+work.KKT[1644]*source[848]+work.KKT[1651]*source[851]+work.KKT[1655]*source[850];
result[147] = work.KKT[1659]*source[147]+work.KKT[1351]*source[770]+work.KKT[1353]*source[771]+work.KKT[1649]*source[849]+work.KKT[1656]*source[852]+work.KKT[1652]*source[851];
result[148] = work.KKT[1542]*source[148]+work.KKT[1543]*source[850]+work.KKT[1544]*source[853];
result[149] = work.KKT[1663]*source[149]+work.KKT[1149]*source[695]+work.KKT[1151]*source[696]+work.KKT[1653]*source[851]+work.KKT[1660]*source[854]+work.KKT[1664]*source[853];
result[150] = work.KKT[1668]*source[150]+work.KKT[1359]*source[773]+work.KKT[1361]*source[774]+work.KKT[1658]*source[852]+work.KKT[1665]*source[855]+work.KKT[1661]*source[854];
result[151] = work.KKT[1545]*source[151]+work.KKT[1546]*source[853]+work.KKT[1547]*source[856];
result[152] = work.KKT[1672]*source[152]+work.KKT[1157]*source[698]+work.KKT[1159]*source[699]+work.KKT[1662]*source[854]+work.KKT[1669]*source[857]+work.KKT[1673]*source[856];
result[153] = work.KKT[1677]*source[153]+work.KKT[1367]*source[776]+work.KKT[1369]*source[777]+work.KKT[1667]*source[855]+work.KKT[1674]*source[858]+work.KKT[1670]*source[857];
result[154] = work.KKT[1548]*source[154]+work.KKT[1549]*source[856]+work.KKT[1550]*source[859];
result[155] = work.KKT[1681]*source[155]+work.KKT[1165]*source[701]+work.KKT[1167]*source[702]+work.KKT[1671]*source[857]+work.KKT[1678]*source[860]+work.KKT[1682]*source[859];
result[156] = work.KKT[1686]*source[156]+work.KKT[1375]*source[779]+work.KKT[1377]*source[780]+work.KKT[1676]*source[858]+work.KKT[1683]*source[861]+work.KKT[1679]*source[860];
result[157] = work.KKT[1551]*source[157]+work.KKT[1552]*source[859]+work.KKT[1553]*source[862];
result[158] = work.KKT[1690]*source[158]+work.KKT[1173]*source[704]+work.KKT[1175]*source[705]+work.KKT[1680]*source[860]+work.KKT[1687]*source[863]+work.KKT[1691]*source[862];
result[159] = work.KKT[1695]*source[159]+work.KKT[1383]*source[782]+work.KKT[1385]*source[783]+work.KKT[1685]*source[861]+work.KKT[1692]*source[864]+work.KKT[1688]*source[863];
result[160] = work.KKT[1554]*source[160]+work.KKT[1555]*source[862]+work.KKT[1556]*source[865];
result[161] = work.KKT[1699]*source[161]+work.KKT[1181]*source[707]+work.KKT[1183]*source[708]+work.KKT[1689]*source[863]+work.KKT[1696]*source[866]+work.KKT[1700]*source[865];
result[162] = work.KKT[1704]*source[162]+work.KKT[1391]*source[785]+work.KKT[1393]*source[786]+work.KKT[1694]*source[864]+work.KKT[1701]*source[867]+work.KKT[1697]*source[866];
result[163] = work.KKT[1557]*source[163]+work.KKT[1558]*source[865]+work.KKT[1559]*source[868];
result[164] = work.KKT[1708]*source[164]+work.KKT[1189]*source[710]+work.KKT[1191]*source[711]+work.KKT[1698]*source[866]+work.KKT[1705]*source[869]+work.KKT[1709]*source[868];
result[165] = work.KKT[1713]*source[165]+work.KKT[1399]*source[788]+work.KKT[1401]*source[789]+work.KKT[1703]*source[867]+work.KKT[1710]*source[870]+work.KKT[1706]*source[869];
result[166] = work.KKT[1560]*source[166]+work.KKT[1561]*source[868]+work.KKT[1562]*source[871];
result[167] = work.KKT[1717]*source[167]+work.KKT[1197]*source[713]+work.KKT[1199]*source[714]+work.KKT[1707]*source[869]+work.KKT[1714]*source[872]+work.KKT[1718]*source[871];
result[168] = work.KKT[1722]*source[168]+work.KKT[1407]*source[791]+work.KKT[1409]*source[792]+work.KKT[1712]*source[870]+work.KKT[1719]*source[873]+work.KKT[1715]*source[872];
result[169] = work.KKT[1563]*source[169]+work.KKT[1564]*source[871]+work.KKT[1565]*source[874];
result[170] = work.KKT[1726]*source[170]+work.KKT[1205]*source[716]+work.KKT[1207]*source[717]+work.KKT[1716]*source[872]+work.KKT[1723]*source[875]+work.KKT[1727]*source[874];
result[171] = work.KKT[1731]*source[171]+work.KKT[1415]*source[794]+work.KKT[1417]*source[795]+work.KKT[1721]*source[873]+work.KKT[1728]*source[876]+work.KKT[1724]*source[875];
result[172] = work.KKT[1566]*source[172]+work.KKT[1567]*source[874]+work.KKT[1568]*source[877];
result[173] = work.KKT[1735]*source[173]+work.KKT[1213]*source[719]+work.KKT[1215]*source[720]+work.KKT[1725]*source[875]+work.KKT[1732]*source[878]+work.KKT[1736]*source[877];
result[174] = work.KKT[1740]*source[174]+work.KKT[1423]*source[797]+work.KKT[1425]*source[798]+work.KKT[1730]*source[876]+work.KKT[1737]*source[879]+work.KKT[1733]*source[878];
result[175] = work.KKT[1569]*source[175]+work.KKT[1570]*source[877]+work.KKT[1571]*source[880];
result[176] = work.KKT[1744]*source[176]+work.KKT[1221]*source[722]+work.KKT[1223]*source[723]+work.KKT[1734]*source[878]+work.KKT[1741]*source[881]+work.KKT[1745]*source[880];
result[177] = work.KKT[1749]*source[177]+work.KKT[1431]*source[800]+work.KKT[1433]*source[801]+work.KKT[1739]*source[879]+work.KKT[1746]*source[882]+work.KKT[1742]*source[881];
result[178] = work.KKT[1572]*source[178]+work.KKT[1573]*source[880]+work.KKT[1574]*source[883];
result[179] = work.KKT[1753]*source[179]+work.KKT[1229]*source[725]+work.KKT[1231]*source[726]+work.KKT[1743]*source[881]+work.KKT[1750]*source[884]+work.KKT[1754]*source[883];
result[180] = work.KKT[1758]*source[180]+work.KKT[1439]*source[803]+work.KKT[1441]*source[804]+work.KKT[1748]*source[882]+work.KKT[1755]*source[885]+work.KKT[1751]*source[884];
result[181] = work.KKT[1575]*source[181]+work.KKT[1576]*source[883]+work.KKT[1577]*source[886];
result[182] = work.KKT[1762]*source[182]+work.KKT[1237]*source[728]+work.KKT[1239]*source[729]+work.KKT[1752]*source[884]+work.KKT[1759]*source[887]+work.KKT[1763]*source[886];
result[183] = work.KKT[1767]*source[183]+work.KKT[1447]*source[806]+work.KKT[1449]*source[807]+work.KKT[1757]*source[885]+work.KKT[1764]*source[888]+work.KKT[1760]*source[887];
result[184] = work.KKT[1578]*source[184]+work.KKT[1579]*source[886]+work.KKT[1580]*source[889];
result[185] = work.KKT[1771]*source[185]+work.KKT[1245]*source[731]+work.KKT[1247]*source[732]+work.KKT[1761]*source[887]+work.KKT[1768]*source[890]+work.KKT[1772]*source[889];
result[186] = work.KKT[1776]*source[186]+work.KKT[1455]*source[809]+work.KKT[1457]*source[810]+work.KKT[1766]*source[888]+work.KKT[1773]*source[891]+work.KKT[1769]*source[890];
result[187] = work.KKT[1581]*source[187]+work.KKT[1582]*source[889]+work.KKT[1583]*source[892];
result[188] = work.KKT[1780]*source[188]+work.KKT[1253]*source[734]+work.KKT[1255]*source[735]+work.KKT[1770]*source[890]+work.KKT[1777]*source[893]+work.KKT[1781]*source[892];
result[189] = work.KKT[1785]*source[189]+work.KKT[1463]*source[812]+work.KKT[1465]*source[813]+work.KKT[1775]*source[891]+work.KKT[1782]*source[894]+work.KKT[1778]*source[893];
result[190] = work.KKT[1584]*source[190]+work.KKT[1585]*source[892]+work.KKT[1586]*source[895];
result[191] = work.KKT[1789]*source[191]+work.KKT[1261]*source[737]+work.KKT[1263]*source[738]+work.KKT[1779]*source[893]+work.KKT[1786]*source[896]+work.KKT[1790]*source[895];
result[192] = work.KKT[1794]*source[192]+work.KKT[1471]*source[815]+work.KKT[1473]*source[816]+work.KKT[1784]*source[894]+work.KKT[1791]*source[897]+work.KKT[1787]*source[896];
result[193] = work.KKT[1587]*source[193]+work.KKT[1588]*source[895]+work.KKT[1589]*source[898];
result[194] = work.KKT[1798]*source[194]+work.KKT[1269]*source[740]+work.KKT[1271]*source[741]+work.KKT[1788]*source[896]+work.KKT[1795]*source[899]+work.KKT[1799]*source[898];
result[195] = work.KKT[1803]*source[195]+work.KKT[1479]*source[818]+work.KKT[1481]*source[819]+work.KKT[1793]*source[897]+work.KKT[1800]*source[900]+work.KKT[1796]*source[899];
result[196] = work.KKT[1590]*source[196]+work.KKT[1591]*source[898]+work.KKT[1592]*source[901];
result[197] = work.KKT[1810]*source[197]+work.KKT[1277]*source[743]+work.KKT[1279]*source[744]+work.KKT[1797]*source[899]+work.KKT[1807]*source[902]+work.KKT[1806]*source[901];
result[198] = work.KKT[1811]*source[198]+work.KKT[1487]*source[821]+work.KKT[1489]*source[822]+work.KKT[1802]*source[900]+work.KKT[1613]*source[903]+work.KKT[1808]*source[902];
result[199] = work.KKT[1593]*source[199]+work.KKT[1595]*source[901]+work.KKT[1594]*source[904];
result[200] = work.KKT[1812]*source[200]+work.KKT[1285]*source[746]+work.KKT[1287]*source[747]+work.KKT[1809]*source[902]+work.KKT[1616]*source[905]+work.KKT[1617]*source[904];
result[201] = work.KKT[1805]*source[201]+work.KKT[1495]*source[824]+work.KKT[1497]*source[825]+work.KKT[1611]*source[903]+work.KKT[1609]*source[906]+work.KKT[1615]*source[905];
result[202] = work.KKT[1596]*source[202]+work.KKT[1597]*source[904]+work.KKT[1521]*source[907];
result[203] = work.KKT[1804]*source[203]+work.KKT[1293]*source[749]+work.KKT[1295]*source[750]+work.KKT[1614]*source[905]+work.KKT[1524]*source[908]+work.KKT[1522]*source[907];
result[204] = work.KKT[1610]*source[204]+work.KKT[1503]*source[827]+work.KKT[1505]*source[828]+work.KKT[1608]*source[906]+work.KKT[1525]*source[909]+work.KKT[1523]*source[908];
result[205] = work.KKT[628]*source[205]+work.KKT[629]*source[907];
result[206] = work.KKT[1304]*source[206]+work.KKT[1301]*source[752]+work.KKT[1303]*source[753]+work.KKT[1305]*source[908];
result[207] = work.KKT[1514]*source[207]+work.KKT[1511]*source[830]+work.KKT[1513]*source[831]+work.KKT[1515]*source[909];
result[208] = work.KKT[0]*source[208]+work.KKT[1]*source[520];
result[209] = work.KKT[2]*source[209]+work.KKT[3]*source[521];
result[210] = work.KKT[4]*source[210]+work.KKT[5]*source[522];
result[211] = work.KKT[6]*source[211]+work.KKT[7]*source[523];
result[212] = work.KKT[8]*source[212]+work.KKT[9]*source[524];
result[213] = work.KKT[10]*source[213]+work.KKT[11]*source[525];
result[214] = work.KKT[12]*source[214]+work.KKT[13]*source[526];
result[215] = work.KKT[14]*source[215]+work.KKT[15]*source[527];
result[216] = work.KKT[16]*source[216]+work.KKT[17]*source[528];
result[217] = work.KKT[18]*source[217]+work.KKT[19]*source[529];
result[218] = work.KKT[20]*source[218]+work.KKT[21]*source[530];
result[219] = work.KKT[22]*source[219]+work.KKT[23]*source[531];
result[220] = work.KKT[24]*source[220]+work.KKT[25]*source[532];
result[221] = work.KKT[26]*source[221]+work.KKT[27]*source[533];
result[222] = work.KKT[28]*source[222]+work.KKT[29]*source[534];
result[223] = work.KKT[30]*source[223]+work.KKT[31]*source[535];
result[224] = work.KKT[32]*source[224]+work.KKT[33]*source[536];
result[225] = work.KKT[34]*source[225]+work.KKT[35]*source[537];
result[226] = work.KKT[36]*source[226]+work.KKT[37]*source[538];
result[227] = work.KKT[38]*source[227]+work.KKT[39]*source[539];
result[228] = work.KKT[40]*source[228]+work.KKT[41]*source[540];
result[229] = work.KKT[42]*source[229]+work.KKT[43]*source[541];
result[230] = work.KKT[44]*source[230]+work.KKT[45]*source[542];
result[231] = work.KKT[46]*source[231]+work.KKT[47]*source[543];
result[232] = work.KKT[48]*source[232]+work.KKT[49]*source[544];
result[233] = work.KKT[50]*source[233]+work.KKT[51]*source[545];
result[234] = work.KKT[52]*source[234]+work.KKT[53]*source[546];
result[235] = work.KKT[54]*source[235]+work.KKT[55]*source[547];
result[236] = work.KKT[56]*source[236]+work.KKT[57]*source[548];
result[237] = work.KKT[58]*source[237]+work.KKT[59]*source[549];
result[238] = work.KKT[60]*source[238]+work.KKT[61]*source[550];
result[239] = work.KKT[62]*source[239]+work.KKT[63]*source[551];
result[240] = work.KKT[64]*source[240]+work.KKT[65]*source[552];
result[241] = work.KKT[66]*source[241]+work.KKT[67]*source[553];
result[242] = work.KKT[68]*source[242]+work.KKT[69]*source[554];
result[243] = work.KKT[70]*source[243]+work.KKT[71]*source[555];
result[244] = work.KKT[72]*source[244]+work.KKT[73]*source[556];
result[245] = work.KKT[74]*source[245]+work.KKT[75]*source[557];
result[246] = work.KKT[76]*source[246]+work.KKT[77]*source[558];
result[247] = work.KKT[78]*source[247]+work.KKT[79]*source[559];
result[248] = work.KKT[80]*source[248]+work.KKT[81]*source[560];
result[249] = work.KKT[82]*source[249]+work.KKT[83]*source[561];
result[250] = work.KKT[84]*source[250]+work.KKT[85]*source[562];
result[251] = work.KKT[86]*source[251]+work.KKT[87]*source[563];
result[252] = work.KKT[88]*source[252]+work.KKT[89]*source[564];
result[253] = work.KKT[90]*source[253]+work.KKT[91]*source[565];
result[254] = work.KKT[92]*source[254]+work.KKT[93]*source[566];
result[255] = work.KKT[94]*source[255]+work.KKT[95]*source[567];
result[256] = work.KKT[96]*source[256]+work.KKT[97]*source[568];
result[257] = work.KKT[98]*source[257]+work.KKT[99]*source[569];
result[258] = work.KKT[100]*source[258]+work.KKT[101]*source[570];
result[259] = work.KKT[102]*source[259]+work.KKT[103]*source[571];
result[260] = work.KKT[104]*source[260]+work.KKT[105]*source[572];
result[261] = work.KKT[106]*source[261]+work.KKT[107]*source[573];
result[262] = work.KKT[108]*source[262]+work.KKT[109]*source[574];
result[263] = work.KKT[110]*source[263]+work.KKT[111]*source[575];
result[264] = work.KKT[112]*source[264]+work.KKT[113]*source[576];
result[265] = work.KKT[114]*source[265]+work.KKT[115]*source[577];
result[266] = work.KKT[116]*source[266]+work.KKT[117]*source[578];
result[267] = work.KKT[118]*source[267]+work.KKT[119]*source[579];
result[268] = work.KKT[120]*source[268]+work.KKT[121]*source[580];
result[269] = work.KKT[122]*source[269]+work.KKT[123]*source[581];
result[270] = work.KKT[124]*source[270]+work.KKT[125]*source[582];
result[271] = work.KKT[126]*source[271]+work.KKT[127]*source[583];
result[272] = work.KKT[128]*source[272]+work.KKT[129]*source[584];
result[273] = work.KKT[130]*source[273]+work.KKT[131]*source[585];
result[274] = work.KKT[132]*source[274]+work.KKT[133]*source[586];
result[275] = work.KKT[134]*source[275]+work.KKT[135]*source[587];
result[276] = work.KKT[136]*source[276]+work.KKT[137]*source[588];
result[277] = work.KKT[138]*source[277]+work.KKT[139]*source[589];
result[278] = work.KKT[140]*source[278]+work.KKT[141]*source[590];
result[279] = work.KKT[142]*source[279]+work.KKT[143]*source[591];
result[280] = work.KKT[144]*source[280]+work.KKT[145]*source[592];
result[281] = work.KKT[146]*source[281]+work.KKT[147]*source[593];
result[282] = work.KKT[148]*source[282]+work.KKT[149]*source[594];
result[283] = work.KKT[150]*source[283]+work.KKT[151]*source[595];
result[284] = work.KKT[152]*source[284]+work.KKT[153]*source[596];
result[285] = work.KKT[154]*source[285]+work.KKT[155]*source[597];
result[286] = work.KKT[156]*source[286]+work.KKT[157]*source[598];
result[287] = work.KKT[158]*source[287]+work.KKT[159]*source[599];
result[288] = work.KKT[160]*source[288]+work.KKT[161]*source[600];
result[289] = work.KKT[162]*source[289]+work.KKT[163]*source[601];
result[290] = work.KKT[164]*source[290]+work.KKT[165]*source[602];
result[291] = work.KKT[166]*source[291]+work.KKT[167]*source[603];
result[292] = work.KKT[168]*source[292]+work.KKT[169]*source[604];
result[293] = work.KKT[170]*source[293]+work.KKT[171]*source[605];
result[294] = work.KKT[172]*source[294]+work.KKT[173]*source[606];
result[295] = work.KKT[174]*source[295]+work.KKT[175]*source[607];
result[296] = work.KKT[176]*source[296]+work.KKT[177]*source[608];
result[297] = work.KKT[178]*source[297]+work.KKT[179]*source[609];
result[298] = work.KKT[180]*source[298]+work.KKT[181]*source[610];
result[299] = work.KKT[182]*source[299]+work.KKT[183]*source[611];
result[300] = work.KKT[184]*source[300]+work.KKT[185]*source[612];
result[301] = work.KKT[186]*source[301]+work.KKT[187]*source[613];
result[302] = work.KKT[188]*source[302]+work.KKT[189]*source[614];
result[303] = work.KKT[190]*source[303]+work.KKT[191]*source[615];
result[304] = work.KKT[192]*source[304]+work.KKT[193]*source[616];
result[305] = work.KKT[194]*source[305]+work.KKT[195]*source[617];
result[306] = work.KKT[196]*source[306]+work.KKT[197]*source[618];
result[307] = work.KKT[198]*source[307]+work.KKT[199]*source[619];
result[308] = work.KKT[200]*source[308]+work.KKT[201]*source[620];
result[309] = work.KKT[202]*source[309]+work.KKT[203]*source[621];
result[310] = work.KKT[204]*source[310]+work.KKT[205]*source[622];
result[311] = work.KKT[206]*source[311]+work.KKT[207]*source[623];
result[312] = work.KKT[208]*source[312]+work.KKT[209]*source[624];
result[313] = work.KKT[210]*source[313]+work.KKT[211]*source[625];
result[314] = work.KKT[212]*source[314]+work.KKT[213]*source[626];
result[315] = work.KKT[214]*source[315]+work.KKT[215]*source[627];
result[316] = work.KKT[216]*source[316]+work.KKT[217]*source[628];
result[317] = work.KKT[218]*source[317]+work.KKT[219]*source[629];
result[318] = work.KKT[220]*source[318]+work.KKT[221]*source[630];
result[319] = work.KKT[222]*source[319]+work.KKT[223]*source[631];
result[320] = work.KKT[224]*source[320]+work.KKT[225]*source[632];
result[321] = work.KKT[226]*source[321]+work.KKT[227]*source[633];
result[322] = work.KKT[228]*source[322]+work.KKT[229]*source[634];
result[323] = work.KKT[230]*source[323]+work.KKT[231]*source[635];
result[324] = work.KKT[232]*source[324]+work.KKT[233]*source[636];
result[325] = work.KKT[234]*source[325]+work.KKT[235]*source[637];
result[326] = work.KKT[236]*source[326]+work.KKT[237]*source[638];
result[327] = work.KKT[238]*source[327]+work.KKT[239]*source[639];
result[328] = work.KKT[240]*source[328]+work.KKT[241]*source[640];
result[329] = work.KKT[242]*source[329]+work.KKT[243]*source[641];
result[330] = work.KKT[244]*source[330]+work.KKT[245]*source[642];
result[331] = work.KKT[246]*source[331]+work.KKT[247]*source[643];
result[332] = work.KKT[248]*source[332]+work.KKT[249]*source[644];
result[333] = work.KKT[250]*source[333]+work.KKT[251]*source[645];
result[334] = work.KKT[252]*source[334]+work.KKT[253]*source[646];
result[335] = work.KKT[254]*source[335]+work.KKT[255]*source[647];
result[336] = work.KKT[256]*source[336]+work.KKT[257]*source[648];
result[337] = work.KKT[258]*source[337]+work.KKT[259]*source[649];
result[338] = work.KKT[260]*source[338]+work.KKT[261]*source[650];
result[339] = work.KKT[262]*source[339]+work.KKT[263]*source[651];
result[340] = work.KKT[264]*source[340]+work.KKT[265]*source[652];
result[341] = work.KKT[266]*source[341]+work.KKT[267]*source[653];
result[342] = work.KKT[268]*source[342]+work.KKT[269]*source[654];
result[343] = work.KKT[270]*source[343]+work.KKT[271]*source[655];
result[344] = work.KKT[272]*source[344]+work.KKT[273]*source[656];
result[345] = work.KKT[274]*source[345]+work.KKT[275]*source[657];
result[346] = work.KKT[276]*source[346]+work.KKT[277]*source[658];
result[347] = work.KKT[278]*source[347]+work.KKT[279]*source[659];
result[348] = work.KKT[280]*source[348]+work.KKT[281]*source[660];
result[349] = work.KKT[282]*source[349]+work.KKT[283]*source[661];
result[350] = work.KKT[284]*source[350]+work.KKT[285]*source[662];
result[351] = work.KKT[286]*source[351]+work.KKT[287]*source[663];
result[352] = work.KKT[288]*source[352]+work.KKT[289]*source[664];
result[353] = work.KKT[290]*source[353]+work.KKT[291]*source[665];
result[354] = work.KKT[292]*source[354]+work.KKT[293]*source[666];
result[355] = work.KKT[294]*source[355]+work.KKT[295]*source[667];
result[356] = work.KKT[296]*source[356]+work.KKT[297]*source[668];
result[357] = work.KKT[298]*source[357]+work.KKT[299]*source[669];
result[358] = work.KKT[300]*source[358]+work.KKT[301]*source[670];
result[359] = work.KKT[302]*source[359]+work.KKT[303]*source[671];
result[360] = work.KKT[304]*source[360]+work.KKT[305]*source[672];
result[361] = work.KKT[306]*source[361]+work.KKT[307]*source[673];
result[362] = work.KKT[308]*source[362]+work.KKT[309]*source[674];
result[363] = work.KKT[310]*source[363]+work.KKT[311]*source[675];
result[364] = work.KKT[312]*source[364]+work.KKT[313]*source[676];
result[365] = work.KKT[314]*source[365]+work.KKT[315]*source[677];
result[366] = work.KKT[316]*source[366]+work.KKT[317]*source[678];
result[367] = work.KKT[318]*source[367]+work.KKT[319]*source[679];
result[368] = work.KKT[320]*source[368]+work.KKT[321]*source[680];
result[369] = work.KKT[322]*source[369]+work.KKT[323]*source[681];
result[370] = work.KKT[324]*source[370]+work.KKT[325]*source[682];
result[371] = work.KKT[326]*source[371]+work.KKT[327]*source[683];
result[372] = work.KKT[328]*source[372]+work.KKT[329]*source[684];
result[373] = work.KKT[330]*source[373]+work.KKT[331]*source[685];
result[374] = work.KKT[332]*source[374]+work.KKT[333]*source[686];
result[375] = work.KKT[334]*source[375]+work.KKT[335]*source[687];
result[376] = work.KKT[336]*source[376]+work.KKT[337]*source[688];
result[377] = work.KKT[338]*source[377]+work.KKT[339]*source[689];
result[378] = work.KKT[340]*source[378]+work.KKT[341]*source[690];
result[379] = work.KKT[342]*source[379]+work.KKT[343]*source[691];
result[380] = work.KKT[344]*source[380]+work.KKT[345]*source[692];
result[381] = work.KKT[346]*source[381]+work.KKT[347]*source[693];
result[382] = work.KKT[348]*source[382]+work.KKT[349]*source[694];
result[383] = work.KKT[350]*source[383]+work.KKT[351]*source[695];
result[384] = work.KKT[352]*source[384]+work.KKT[353]*source[696];
result[385] = work.KKT[354]*source[385]+work.KKT[355]*source[697];
result[386] = work.KKT[356]*source[386]+work.KKT[357]*source[698];
result[387] = work.KKT[358]*source[387]+work.KKT[359]*source[699];
result[388] = work.KKT[360]*source[388]+work.KKT[361]*source[700];
result[389] = work.KKT[362]*source[389]+work.KKT[363]*source[701];
result[390] = work.KKT[364]*source[390]+work.KKT[365]*source[702];
result[391] = work.KKT[366]*source[391]+work.KKT[367]*source[703];
result[392] = work.KKT[368]*source[392]+work.KKT[369]*source[704];
result[393] = work.KKT[370]*source[393]+work.KKT[371]*source[705];
result[394] = work.KKT[372]*source[394]+work.KKT[373]*source[706];
result[395] = work.KKT[374]*source[395]+work.KKT[375]*source[707];
result[396] = work.KKT[376]*source[396]+work.KKT[377]*source[708];
result[397] = work.KKT[378]*source[397]+work.KKT[379]*source[709];
result[398] = work.KKT[380]*source[398]+work.KKT[381]*source[710];
result[399] = work.KKT[382]*source[399]+work.KKT[383]*source[711];
result[400] = work.KKT[384]*source[400]+work.KKT[385]*source[712];
result[401] = work.KKT[386]*source[401]+work.KKT[387]*source[713];
result[402] = work.KKT[388]*source[402]+work.KKT[389]*source[714];
result[403] = work.KKT[390]*source[403]+work.KKT[391]*source[715];
result[404] = work.KKT[392]*source[404]+work.KKT[393]*source[716];
result[405] = work.KKT[394]*source[405]+work.KKT[395]*source[717];
result[406] = work.KKT[396]*source[406]+work.KKT[397]*source[718];
result[407] = work.KKT[398]*source[407]+work.KKT[399]*source[719];
result[408] = work.KKT[400]*source[408]+work.KKT[401]*source[720];
result[409] = work.KKT[402]*source[409]+work.KKT[403]*source[721];
result[410] = work.KKT[404]*source[410]+work.KKT[405]*source[722];
result[411] = work.KKT[406]*source[411]+work.KKT[407]*source[723];
result[412] = work.KKT[408]*source[412]+work.KKT[409]*source[724];
result[413] = work.KKT[410]*source[413]+work.KKT[411]*source[725];
result[414] = work.KKT[412]*source[414]+work.KKT[413]*source[726];
result[415] = work.KKT[414]*source[415]+work.KKT[415]*source[727];
result[416] = work.KKT[416]*source[416]+work.KKT[417]*source[728];
result[417] = work.KKT[418]*source[417]+work.KKT[419]*source[729];
result[418] = work.KKT[420]*source[418]+work.KKT[421]*source[730];
result[419] = work.KKT[422]*source[419]+work.KKT[423]*source[731];
result[420] = work.KKT[424]*source[420]+work.KKT[425]*source[732];
result[421] = work.KKT[426]*source[421]+work.KKT[427]*source[733];
result[422] = work.KKT[428]*source[422]+work.KKT[429]*source[734];
result[423] = work.KKT[430]*source[423]+work.KKT[431]*source[735];
result[424] = work.KKT[432]*source[424]+work.KKT[433]*source[736];
result[425] = work.KKT[434]*source[425]+work.KKT[435]*source[737];
result[426] = work.KKT[436]*source[426]+work.KKT[437]*source[738];
result[427] = work.KKT[438]*source[427]+work.KKT[439]*source[739];
result[428] = work.KKT[440]*source[428]+work.KKT[441]*source[740];
result[429] = work.KKT[442]*source[429]+work.KKT[443]*source[741];
result[430] = work.KKT[444]*source[430]+work.KKT[445]*source[742];
result[431] = work.KKT[446]*source[431]+work.KKT[447]*source[743];
result[432] = work.KKT[448]*source[432]+work.KKT[449]*source[744];
result[433] = work.KKT[450]*source[433]+work.KKT[451]*source[745];
result[434] = work.KKT[452]*source[434]+work.KKT[453]*source[746];
result[435] = work.KKT[454]*source[435]+work.KKT[455]*source[747];
result[436] = work.KKT[456]*source[436]+work.KKT[457]*source[748];
result[437] = work.KKT[458]*source[437]+work.KKT[459]*source[749];
result[438] = work.KKT[460]*source[438]+work.KKT[461]*source[750];
result[439] = work.KKT[462]*source[439]+work.KKT[463]*source[751];
result[440] = work.KKT[464]*source[440]+work.KKT[465]*source[752];
result[441] = work.KKT[466]*source[441]+work.KKT[467]*source[753];
result[442] = work.KKT[468]*source[442]+work.KKT[469]*source[754];
result[443] = work.KKT[470]*source[443]+work.KKT[471]*source[755];
result[444] = work.KKT[472]*source[444]+work.KKT[473]*source[756];
result[445] = work.KKT[474]*source[445]+work.KKT[475]*source[757];
result[446] = work.KKT[476]*source[446]+work.KKT[477]*source[758];
result[447] = work.KKT[478]*source[447]+work.KKT[479]*source[759];
result[448] = work.KKT[480]*source[448]+work.KKT[481]*source[760];
result[449] = work.KKT[482]*source[449]+work.KKT[483]*source[761];
result[450] = work.KKT[484]*source[450]+work.KKT[485]*source[762];
result[451] = work.KKT[486]*source[451]+work.KKT[487]*source[763];
result[452] = work.KKT[488]*source[452]+work.KKT[489]*source[764];
result[453] = work.KKT[490]*source[453]+work.KKT[491]*source[765];
result[454] = work.KKT[492]*source[454]+work.KKT[493]*source[766];
result[455] = work.KKT[494]*source[455]+work.KKT[495]*source[767];
result[456] = work.KKT[496]*source[456]+work.KKT[497]*source[768];
result[457] = work.KKT[498]*source[457]+work.KKT[499]*source[769];
result[458] = work.KKT[500]*source[458]+work.KKT[501]*source[770];
result[459] = work.KKT[502]*source[459]+work.KKT[503]*source[771];
result[460] = work.KKT[504]*source[460]+work.KKT[505]*source[772];
result[461] = work.KKT[506]*source[461]+work.KKT[507]*source[773];
result[462] = work.KKT[508]*source[462]+work.KKT[509]*source[774];
result[463] = work.KKT[510]*source[463]+work.KKT[511]*source[775];
result[464] = work.KKT[512]*source[464]+work.KKT[513]*source[776];
result[465] = work.KKT[514]*source[465]+work.KKT[515]*source[777];
result[466] = work.KKT[516]*source[466]+work.KKT[517]*source[778];
result[467] = work.KKT[518]*source[467]+work.KKT[519]*source[779];
result[468] = work.KKT[520]*source[468]+work.KKT[521]*source[780];
result[469] = work.KKT[522]*source[469]+work.KKT[523]*source[781];
result[470] = work.KKT[524]*source[470]+work.KKT[525]*source[782];
result[471] = work.KKT[526]*source[471]+work.KKT[527]*source[783];
result[472] = work.KKT[528]*source[472]+work.KKT[529]*source[784];
result[473] = work.KKT[530]*source[473]+work.KKT[531]*source[785];
result[474] = work.KKT[532]*source[474]+work.KKT[533]*source[786];
result[475] = work.KKT[534]*source[475]+work.KKT[535]*source[787];
result[476] = work.KKT[536]*source[476]+work.KKT[537]*source[788];
result[477] = work.KKT[538]*source[477]+work.KKT[539]*source[789];
result[478] = work.KKT[540]*source[478]+work.KKT[541]*source[790];
result[479] = work.KKT[542]*source[479]+work.KKT[543]*source[791];
result[480] = work.KKT[544]*source[480]+work.KKT[545]*source[792];
result[481] = work.KKT[546]*source[481]+work.KKT[547]*source[793];
result[482] = work.KKT[548]*source[482]+work.KKT[549]*source[794];
result[483] = work.KKT[550]*source[483]+work.KKT[551]*source[795];
result[484] = work.KKT[552]*source[484]+work.KKT[553]*source[796];
result[485] = work.KKT[554]*source[485]+work.KKT[555]*source[797];
result[486] = work.KKT[556]*source[486]+work.KKT[557]*source[798];
result[487] = work.KKT[558]*source[487]+work.KKT[559]*source[799];
result[488] = work.KKT[560]*source[488]+work.KKT[561]*source[800];
result[489] = work.KKT[562]*source[489]+work.KKT[563]*source[801];
result[490] = work.KKT[564]*source[490]+work.KKT[565]*source[802];
result[491] = work.KKT[566]*source[491]+work.KKT[567]*source[803];
result[492] = work.KKT[568]*source[492]+work.KKT[569]*source[804];
result[493] = work.KKT[570]*source[493]+work.KKT[571]*source[805];
result[494] = work.KKT[572]*source[494]+work.KKT[573]*source[806];
result[495] = work.KKT[574]*source[495]+work.KKT[575]*source[807];
result[496] = work.KKT[576]*source[496]+work.KKT[577]*source[808];
result[497] = work.KKT[578]*source[497]+work.KKT[579]*source[809];
result[498] = work.KKT[580]*source[498]+work.KKT[581]*source[810];
result[499] = work.KKT[582]*source[499]+work.KKT[583]*source[811];
result[500] = work.KKT[584]*source[500]+work.KKT[585]*source[812];
result[501] = work.KKT[586]*source[501]+work.KKT[587]*source[813];
result[502] = work.KKT[588]*source[502]+work.KKT[589]*source[814];
result[503] = work.KKT[590]*source[503]+work.KKT[591]*source[815];
result[504] = work.KKT[592]*source[504]+work.KKT[593]*source[816];
result[505] = work.KKT[594]*source[505]+work.KKT[595]*source[817];
result[506] = work.KKT[596]*source[506]+work.KKT[597]*source[818];
result[507] = work.KKT[598]*source[507]+work.KKT[599]*source[819];
result[508] = work.KKT[600]*source[508]+work.KKT[601]*source[820];
result[509] = work.KKT[602]*source[509]+work.KKT[603]*source[821];
result[510] = work.KKT[604]*source[510]+work.KKT[605]*source[822];
result[511] = work.KKT[606]*source[511]+work.KKT[607]*source[823];
result[512] = work.KKT[608]*source[512]+work.KKT[609]*source[824];
result[513] = work.KKT[610]*source[513]+work.KKT[611]*source[825];
result[514] = work.KKT[612]*source[514]+work.KKT[613]*source[826];
result[515] = work.KKT[614]*source[515]+work.KKT[615]*source[827];
result[516] = work.KKT[616]*source[516]+work.KKT[617]*source[828];
result[517] = work.KKT[618]*source[517]+work.KKT[619]*source[829];
result[518] = work.KKT[620]*source[518]+work.KKT[621]*source[830];
result[519] = work.KKT[622]*source[519]+work.KKT[623]*source[831];
result[520] = work.KKT[1]*source[208]+work.KKT[630]*source[520]+work.KKT[631]*source[0];
result[521] = work.KKT[3]*source[209]+work.KKT[634]*source[521]+work.KKT[632]*source[0]+work.KKT[635]*source[104];
result[522] = work.KKT[5]*source[210]+work.KKT[636]*source[522]+work.KKT[633]*source[0]+work.KKT[637]*source[104];
result[523] = work.KKT[7]*source[211]+work.KKT[638]*source[523]+work.KKT[639]*source[1];
result[524] = work.KKT[9]*source[212]+work.KKT[642]*source[524]+work.KKT[640]*source[1]+work.KKT[643]*source[105];
result[525] = work.KKT[11]*source[213]+work.KKT[644]*source[525]+work.KKT[641]*source[1]+work.KKT[645]*source[105];
result[526] = work.KKT[13]*source[214]+work.KKT[646]*source[526]+work.KKT[647]*source[2];
result[527] = work.KKT[15]*source[215]+work.KKT[650]*source[527]+work.KKT[648]*source[2]+work.KKT[651]*source[106];
result[528] = work.KKT[17]*source[216]+work.KKT[652]*source[528]+work.KKT[649]*source[2]+work.KKT[653]*source[106];
result[529] = work.KKT[19]*source[217]+work.KKT[654]*source[529]+work.KKT[655]*source[3];
result[530] = work.KKT[21]*source[218]+work.KKT[658]*source[530]+work.KKT[656]*source[3]+work.KKT[659]*source[107];
result[531] = work.KKT[23]*source[219]+work.KKT[660]*source[531]+work.KKT[657]*source[3]+work.KKT[661]*source[107];
result[532] = work.KKT[25]*source[220]+work.KKT[662]*source[532]+work.KKT[663]*source[4];
result[533] = work.KKT[27]*source[221]+work.KKT[666]*source[533]+work.KKT[664]*source[4]+work.KKT[667]*source[108];
result[534] = work.KKT[29]*source[222]+work.KKT[668]*source[534]+work.KKT[665]*source[4]+work.KKT[669]*source[108];
result[535] = work.KKT[31]*source[223]+work.KKT[670]*source[535]+work.KKT[671]*source[5];
result[536] = work.KKT[33]*source[224]+work.KKT[674]*source[536]+work.KKT[672]*source[5]+work.KKT[675]*source[109];
result[537] = work.KKT[35]*source[225]+work.KKT[676]*source[537]+work.KKT[673]*source[5]+work.KKT[677]*source[109];
result[538] = work.KKT[37]*source[226]+work.KKT[678]*source[538]+work.KKT[679]*source[6];
result[539] = work.KKT[39]*source[227]+work.KKT[682]*source[539]+work.KKT[680]*source[6]+work.KKT[683]*source[110];
result[540] = work.KKT[41]*source[228]+work.KKT[684]*source[540]+work.KKT[681]*source[6]+work.KKT[685]*source[110];
result[541] = work.KKT[43]*source[229]+work.KKT[686]*source[541]+work.KKT[687]*source[7];
result[542] = work.KKT[45]*source[230]+work.KKT[690]*source[542]+work.KKT[688]*source[7]+work.KKT[691]*source[111];
result[543] = work.KKT[47]*source[231]+work.KKT[692]*source[543]+work.KKT[689]*source[7]+work.KKT[693]*source[111];
result[544] = work.KKT[49]*source[232]+work.KKT[694]*source[544]+work.KKT[695]*source[8];
result[545] = work.KKT[51]*source[233]+work.KKT[698]*source[545]+work.KKT[696]*source[8]+work.KKT[699]*source[112];
result[546] = work.KKT[53]*source[234]+work.KKT[700]*source[546]+work.KKT[697]*source[8]+work.KKT[701]*source[112];
result[547] = work.KKT[55]*source[235]+work.KKT[702]*source[547]+work.KKT[703]*source[9];
result[548] = work.KKT[57]*source[236]+work.KKT[706]*source[548]+work.KKT[704]*source[9]+work.KKT[707]*source[113];
result[549] = work.KKT[59]*source[237]+work.KKT[708]*source[549]+work.KKT[705]*source[9]+work.KKT[709]*source[113];
result[550] = work.KKT[61]*source[238]+work.KKT[710]*source[550]+work.KKT[711]*source[10];
result[551] = work.KKT[63]*source[239]+work.KKT[714]*source[551]+work.KKT[712]*source[10]+work.KKT[715]*source[114];
result[552] = work.KKT[65]*source[240]+work.KKT[716]*source[552]+work.KKT[713]*source[10]+work.KKT[717]*source[114];
result[553] = work.KKT[67]*source[241]+work.KKT[718]*source[553]+work.KKT[719]*source[11];
result[554] = work.KKT[69]*source[242]+work.KKT[722]*source[554]+work.KKT[720]*source[11]+work.KKT[723]*source[115];
result[555] = work.KKT[71]*source[243]+work.KKT[724]*source[555]+work.KKT[721]*source[11]+work.KKT[725]*source[115];
result[556] = work.KKT[73]*source[244]+work.KKT[726]*source[556]+work.KKT[727]*source[12];
result[557] = work.KKT[75]*source[245]+work.KKT[730]*source[557]+work.KKT[728]*source[12]+work.KKT[731]*source[116];
result[558] = work.KKT[77]*source[246]+work.KKT[732]*source[558]+work.KKT[729]*source[12]+work.KKT[733]*source[116];
result[559] = work.KKT[79]*source[247]+work.KKT[734]*source[559]+work.KKT[735]*source[13];
result[560] = work.KKT[81]*source[248]+work.KKT[738]*source[560]+work.KKT[736]*source[13]+work.KKT[739]*source[117];
result[561] = work.KKT[83]*source[249]+work.KKT[740]*source[561]+work.KKT[737]*source[13]+work.KKT[741]*source[117];
result[562] = work.KKT[85]*source[250]+work.KKT[742]*source[562]+work.KKT[743]*source[14];
result[563] = work.KKT[87]*source[251]+work.KKT[746]*source[563]+work.KKT[744]*source[14]+work.KKT[747]*source[118];
result[564] = work.KKT[89]*source[252]+work.KKT[748]*source[564]+work.KKT[745]*source[14]+work.KKT[749]*source[118];
result[565] = work.KKT[91]*source[253]+work.KKT[750]*source[565]+work.KKT[751]*source[15];
result[566] = work.KKT[93]*source[254]+work.KKT[754]*source[566]+work.KKT[752]*source[15]+work.KKT[755]*source[119];
result[567] = work.KKT[95]*source[255]+work.KKT[756]*source[567]+work.KKT[753]*source[15]+work.KKT[757]*source[119];
result[568] = work.KKT[97]*source[256]+work.KKT[758]*source[568]+work.KKT[759]*source[16];
result[569] = work.KKT[99]*source[257]+work.KKT[762]*source[569]+work.KKT[760]*source[16]+work.KKT[763]*source[120];
result[570] = work.KKT[101]*source[258]+work.KKT[764]*source[570]+work.KKT[761]*source[16]+work.KKT[765]*source[120];
result[571] = work.KKT[103]*source[259]+work.KKT[766]*source[571]+work.KKT[767]*source[17];
result[572] = work.KKT[105]*source[260]+work.KKT[770]*source[572]+work.KKT[768]*source[17]+work.KKT[771]*source[121];
result[573] = work.KKT[107]*source[261]+work.KKT[772]*source[573]+work.KKT[769]*source[17]+work.KKT[773]*source[121];
result[574] = work.KKT[109]*source[262]+work.KKT[774]*source[574]+work.KKT[775]*source[18];
result[575] = work.KKT[111]*source[263]+work.KKT[778]*source[575]+work.KKT[776]*source[18]+work.KKT[779]*source[122];
result[576] = work.KKT[113]*source[264]+work.KKT[780]*source[576]+work.KKT[777]*source[18]+work.KKT[781]*source[122];
result[577] = work.KKT[115]*source[265]+work.KKT[782]*source[577]+work.KKT[783]*source[19];
result[578] = work.KKT[117]*source[266]+work.KKT[786]*source[578]+work.KKT[784]*source[19]+work.KKT[787]*source[123];
result[579] = work.KKT[119]*source[267]+work.KKT[788]*source[579]+work.KKT[785]*source[19]+work.KKT[789]*source[123];
result[580] = work.KKT[121]*source[268]+work.KKT[790]*source[580]+work.KKT[791]*source[20];
result[581] = work.KKT[123]*source[269]+work.KKT[794]*source[581]+work.KKT[792]*source[20]+work.KKT[795]*source[124];
result[582] = work.KKT[125]*source[270]+work.KKT[796]*source[582]+work.KKT[793]*source[20]+work.KKT[797]*source[124];
result[583] = work.KKT[127]*source[271]+work.KKT[798]*source[583]+work.KKT[799]*source[21];
result[584] = work.KKT[129]*source[272]+work.KKT[802]*source[584]+work.KKT[800]*source[21]+work.KKT[803]*source[125];
result[585] = work.KKT[131]*source[273]+work.KKT[804]*source[585]+work.KKT[801]*source[21]+work.KKT[805]*source[125];
result[586] = work.KKT[133]*source[274]+work.KKT[806]*source[586]+work.KKT[807]*source[22];
result[587] = work.KKT[135]*source[275]+work.KKT[810]*source[587]+work.KKT[808]*source[22]+work.KKT[811]*source[126];
result[588] = work.KKT[137]*source[276]+work.KKT[812]*source[588]+work.KKT[809]*source[22]+work.KKT[813]*source[126];
result[589] = work.KKT[139]*source[277]+work.KKT[814]*source[589]+work.KKT[815]*source[23];
result[590] = work.KKT[141]*source[278]+work.KKT[818]*source[590]+work.KKT[816]*source[23]+work.KKT[819]*source[127];
result[591] = work.KKT[143]*source[279]+work.KKT[820]*source[591]+work.KKT[817]*source[23]+work.KKT[821]*source[127];
result[592] = work.KKT[145]*source[280]+work.KKT[822]*source[592]+work.KKT[823]*source[24];
result[593] = work.KKT[147]*source[281]+work.KKT[826]*source[593]+work.KKT[824]*source[24]+work.KKT[827]*source[128];
result[594] = work.KKT[149]*source[282]+work.KKT[828]*source[594]+work.KKT[825]*source[24]+work.KKT[829]*source[128];
result[595] = work.KKT[151]*source[283]+work.KKT[830]*source[595]+work.KKT[831]*source[25];
result[596] = work.KKT[153]*source[284]+work.KKT[834]*source[596]+work.KKT[832]*source[25]+work.KKT[835]*source[129];
result[597] = work.KKT[155]*source[285]+work.KKT[836]*source[597]+work.KKT[833]*source[25]+work.KKT[837]*source[129];
result[598] = work.KKT[157]*source[286]+work.KKT[838]*source[598]+work.KKT[839]*source[26];
result[599] = work.KKT[159]*source[287]+work.KKT[842]*source[599]+work.KKT[840]*source[26]+work.KKT[843]*source[104];
result[600] = work.KKT[161]*source[288]+work.KKT[844]*source[600]+work.KKT[841]*source[26]+work.KKT[845]*source[104];
result[601] = work.KKT[163]*source[289]+work.KKT[846]*source[601]+work.KKT[847]*source[27];
result[602] = work.KKT[165]*source[290]+work.KKT[850]*source[602]+work.KKT[848]*source[27]+work.KKT[851]*source[104]+work.KKT[852]*source[105];
result[603] = work.KKT[167]*source[291]+work.KKT[853]*source[603]+work.KKT[849]*source[27]+work.KKT[854]*source[104]+work.KKT[855]*source[105];
result[604] = work.KKT[169]*source[292]+work.KKT[856]*source[604]+work.KKT[857]*source[28];
result[605] = work.KKT[171]*source[293]+work.KKT[860]*source[605]+work.KKT[858]*source[28]+work.KKT[861]*source[105]+work.KKT[862]*source[106];
result[606] = work.KKT[173]*source[294]+work.KKT[863]*source[606]+work.KKT[859]*source[28]+work.KKT[864]*source[105]+work.KKT[865]*source[106];
result[607] = work.KKT[175]*source[295]+work.KKT[866]*source[607]+work.KKT[867]*source[29];
result[608] = work.KKT[177]*source[296]+work.KKT[870]*source[608]+work.KKT[868]*source[29]+work.KKT[871]*source[106]+work.KKT[872]*source[107];
result[609] = work.KKT[179]*source[297]+work.KKT[873]*source[609]+work.KKT[869]*source[29]+work.KKT[874]*source[106]+work.KKT[875]*source[107];
result[610] = work.KKT[181]*source[298]+work.KKT[876]*source[610]+work.KKT[877]*source[30];
result[611] = work.KKT[183]*source[299]+work.KKT[880]*source[611]+work.KKT[878]*source[30]+work.KKT[881]*source[107]+work.KKT[882]*source[108];
result[612] = work.KKT[185]*source[300]+work.KKT[883]*source[612]+work.KKT[879]*source[30]+work.KKT[884]*source[107]+work.KKT[885]*source[108];
result[613] = work.KKT[187]*source[301]+work.KKT[886]*source[613]+work.KKT[887]*source[31];
result[614] = work.KKT[189]*source[302]+work.KKT[890]*source[614]+work.KKT[888]*source[31]+work.KKT[891]*source[108]+work.KKT[892]*source[109];
result[615] = work.KKT[191]*source[303]+work.KKT[893]*source[615]+work.KKT[889]*source[31]+work.KKT[894]*source[108]+work.KKT[895]*source[109];
result[616] = work.KKT[193]*source[304]+work.KKT[896]*source[616]+work.KKT[897]*source[32];
result[617] = work.KKT[195]*source[305]+work.KKT[900]*source[617]+work.KKT[898]*source[32]+work.KKT[901]*source[109]+work.KKT[902]*source[110];
result[618] = work.KKT[197]*source[306]+work.KKT[903]*source[618]+work.KKT[899]*source[32]+work.KKT[904]*source[109]+work.KKT[905]*source[110];
result[619] = work.KKT[199]*source[307]+work.KKT[906]*source[619]+work.KKT[907]*source[33];
result[620] = work.KKT[201]*source[308]+work.KKT[910]*source[620]+work.KKT[908]*source[33]+work.KKT[911]*source[110]+work.KKT[912]*source[111];
result[621] = work.KKT[203]*source[309]+work.KKT[913]*source[621]+work.KKT[909]*source[33]+work.KKT[914]*source[110]+work.KKT[915]*source[111];
result[622] = work.KKT[205]*source[310]+work.KKT[916]*source[622]+work.KKT[917]*source[34];
result[623] = work.KKT[207]*source[311]+work.KKT[920]*source[623]+work.KKT[918]*source[34]+work.KKT[921]*source[111]+work.KKT[922]*source[112];
result[624] = work.KKT[209]*source[312]+work.KKT[923]*source[624]+work.KKT[919]*source[34]+work.KKT[924]*source[111]+work.KKT[925]*source[112];
result[625] = work.KKT[211]*source[313]+work.KKT[926]*source[625]+work.KKT[927]*source[35];
result[626] = work.KKT[213]*source[314]+work.KKT[930]*source[626]+work.KKT[928]*source[35]+work.KKT[931]*source[112]+work.KKT[932]*source[113];
result[627] = work.KKT[215]*source[315]+work.KKT[933]*source[627]+work.KKT[929]*source[35]+work.KKT[934]*source[112]+work.KKT[935]*source[113];
result[628] = work.KKT[217]*source[316]+work.KKT[936]*source[628]+work.KKT[937]*source[36];
result[629] = work.KKT[219]*source[317]+work.KKT[940]*source[629]+work.KKT[938]*source[36]+work.KKT[941]*source[113]+work.KKT[942]*source[114];
result[630] = work.KKT[221]*source[318]+work.KKT[943]*source[630]+work.KKT[939]*source[36]+work.KKT[944]*source[113]+work.KKT[945]*source[114];
result[631] = work.KKT[223]*source[319]+work.KKT[946]*source[631]+work.KKT[947]*source[37];
result[632] = work.KKT[225]*source[320]+work.KKT[950]*source[632]+work.KKT[948]*source[37]+work.KKT[951]*source[114]+work.KKT[952]*source[115];
result[633] = work.KKT[227]*source[321]+work.KKT[953]*source[633]+work.KKT[949]*source[37]+work.KKT[954]*source[114]+work.KKT[955]*source[115];
result[634] = work.KKT[229]*source[322]+work.KKT[956]*source[634]+work.KKT[957]*source[38];
result[635] = work.KKT[231]*source[323]+work.KKT[960]*source[635]+work.KKT[958]*source[38]+work.KKT[961]*source[115]+work.KKT[962]*source[116];
result[636] = work.KKT[233]*source[324]+work.KKT[963]*source[636]+work.KKT[959]*source[38]+work.KKT[964]*source[115]+work.KKT[965]*source[116];
result[637] = work.KKT[235]*source[325]+work.KKT[966]*source[637]+work.KKT[967]*source[39];
result[638] = work.KKT[237]*source[326]+work.KKT[970]*source[638]+work.KKT[968]*source[39]+work.KKT[971]*source[116]+work.KKT[972]*source[117];
result[639] = work.KKT[239]*source[327]+work.KKT[973]*source[639]+work.KKT[969]*source[39]+work.KKT[974]*source[116]+work.KKT[975]*source[117];
result[640] = work.KKT[241]*source[328]+work.KKT[976]*source[640]+work.KKT[977]*source[40];
result[641] = work.KKT[243]*source[329]+work.KKT[980]*source[641]+work.KKT[978]*source[40]+work.KKT[981]*source[117]+work.KKT[982]*source[118];
result[642] = work.KKT[245]*source[330]+work.KKT[983]*source[642]+work.KKT[979]*source[40]+work.KKT[984]*source[117]+work.KKT[985]*source[118];
result[643] = work.KKT[247]*source[331]+work.KKT[986]*source[643]+work.KKT[987]*source[41];
result[644] = work.KKT[249]*source[332]+work.KKT[990]*source[644]+work.KKT[988]*source[41]+work.KKT[991]*source[118]+work.KKT[992]*source[119];
result[645] = work.KKT[251]*source[333]+work.KKT[993]*source[645]+work.KKT[989]*source[41]+work.KKT[994]*source[118]+work.KKT[995]*source[119];
result[646] = work.KKT[253]*source[334]+work.KKT[996]*source[646]+work.KKT[997]*source[42];
result[647] = work.KKT[255]*source[335]+work.KKT[1000]*source[647]+work.KKT[998]*source[42]+work.KKT[1001]*source[119]+work.KKT[1002]*source[120];
result[648] = work.KKT[257]*source[336]+work.KKT[1003]*source[648]+work.KKT[999]*source[42]+work.KKT[1004]*source[119]+work.KKT[1005]*source[120];
result[649] = work.KKT[259]*source[337]+work.KKT[1006]*source[649]+work.KKT[1007]*source[43];
result[650] = work.KKT[261]*source[338]+work.KKT[1010]*source[650]+work.KKT[1008]*source[43]+work.KKT[1011]*source[120]+work.KKT[1012]*source[121];
result[651] = work.KKT[263]*source[339]+work.KKT[1013]*source[651]+work.KKT[1009]*source[43]+work.KKT[1014]*source[120]+work.KKT[1015]*source[121];
result[652] = work.KKT[265]*source[340]+work.KKT[1016]*source[652]+work.KKT[1017]*source[44];
result[653] = work.KKT[267]*source[341]+work.KKT[1020]*source[653]+work.KKT[1018]*source[44]+work.KKT[1021]*source[121]+work.KKT[1022]*source[122];
result[654] = work.KKT[269]*source[342]+work.KKT[1023]*source[654]+work.KKT[1019]*source[44]+work.KKT[1024]*source[121]+work.KKT[1025]*source[122];
result[655] = work.KKT[271]*source[343]+work.KKT[1026]*source[655]+work.KKT[1027]*source[45];
result[656] = work.KKT[273]*source[344]+work.KKT[1030]*source[656]+work.KKT[1028]*source[45]+work.KKT[1031]*source[122]+work.KKT[1032]*source[123];
result[657] = work.KKT[275]*source[345]+work.KKT[1033]*source[657]+work.KKT[1029]*source[45]+work.KKT[1034]*source[122]+work.KKT[1035]*source[123];
result[658] = work.KKT[277]*source[346]+work.KKT[1036]*source[658]+work.KKT[1037]*source[46];
result[659] = work.KKT[279]*source[347]+work.KKT[1040]*source[659]+work.KKT[1038]*source[46]+work.KKT[1041]*source[123]+work.KKT[1042]*source[124];
result[660] = work.KKT[281]*source[348]+work.KKT[1043]*source[660]+work.KKT[1039]*source[46]+work.KKT[1044]*source[123]+work.KKT[1045]*source[124];
result[661] = work.KKT[283]*source[349]+work.KKT[1046]*source[661]+work.KKT[1047]*source[47];
result[662] = work.KKT[285]*source[350]+work.KKT[1050]*source[662]+work.KKT[1048]*source[47]+work.KKT[1051]*source[124]+work.KKT[1052]*source[125];
result[663] = work.KKT[287]*source[351]+work.KKT[1053]*source[663]+work.KKT[1049]*source[47]+work.KKT[1054]*source[124]+work.KKT[1055]*source[125];
result[664] = work.KKT[289]*source[352]+work.KKT[1056]*source[664]+work.KKT[1057]*source[48];
result[665] = work.KKT[291]*source[353]+work.KKT[1060]*source[665]+work.KKT[1058]*source[48]+work.KKT[1061]*source[125]+work.KKT[1062]*source[126];
result[666] = work.KKT[293]*source[354]+work.KKT[1063]*source[666]+work.KKT[1059]*source[48]+work.KKT[1064]*source[125]+work.KKT[1065]*source[126];
result[667] = work.KKT[295]*source[355]+work.KKT[1066]*source[667]+work.KKT[1067]*source[49];
result[668] = work.KKT[297]*source[356]+work.KKT[1070]*source[668]+work.KKT[1068]*source[49]+work.KKT[1071]*source[126]+work.KKT[1072]*source[127];
result[669] = work.KKT[299]*source[357]+work.KKT[1073]*source[669]+work.KKT[1069]*source[49]+work.KKT[1074]*source[126]+work.KKT[1075]*source[127];
result[670] = work.KKT[301]*source[358]+work.KKT[1076]*source[670]+work.KKT[1077]*source[50];
result[671] = work.KKT[303]*source[359]+work.KKT[1080]*source[671]+work.KKT[1078]*source[50]+work.KKT[1082]*source[127]+work.KKT[1081]*source[128];
result[672] = work.KKT[305]*source[360]+work.KKT[1083]*source[672]+work.KKT[1079]*source[50]+work.KKT[1085]*source[127]+work.KKT[1084]*source[128];
result[673] = work.KKT[307]*source[361]+work.KKT[1086]*source[673]+work.KKT[1087]*source[51];
result[674] = work.KKT[309]*source[362]+work.KKT[1090]*source[674]+work.KKT[1088]*source[51]+work.KKT[1092]*source[128]+work.KKT[1091]*source[129];
result[675] = work.KKT[311]*source[363]+work.KKT[1093]*source[675]+work.KKT[1089]*source[51]+work.KKT[1095]*source[128]+work.KKT[1094]*source[129];
result[676] = work.KKT[313]*source[364]+work.KKT[1096]*source[676]+work.KKT[1097]*source[52];
result[677] = work.KKT[315]*source[365]+work.KKT[1100]*source[677]+work.KKT[1098]*source[52]+work.KKT[1101]*source[131];
result[678] = work.KKT[317]*source[366]+work.KKT[1102]*source[678]+work.KKT[1099]*source[52]+work.KKT[1103]*source[131];
result[679] = work.KKT[319]*source[367]+work.KKT[1104]*source[679]+work.KKT[1105]*source[53];
result[680] = work.KKT[321]*source[368]+work.KKT[1108]*source[680]+work.KKT[1106]*source[53]+work.KKT[1109]*source[134];
result[681] = work.KKT[323]*source[369]+work.KKT[1110]*source[681]+work.KKT[1107]*source[53]+work.KKT[1111]*source[134];
result[682] = work.KKT[325]*source[370]+work.KKT[1112]*source[682]+work.KKT[1113]*source[54];
result[683] = work.KKT[327]*source[371]+work.KKT[1116]*source[683]+work.KKT[1114]*source[54]+work.KKT[1117]*source[137];
result[684] = work.KKT[329]*source[372]+work.KKT[1118]*source[684]+work.KKT[1115]*source[54]+work.KKT[1119]*source[137];
result[685] = work.KKT[331]*source[373]+work.KKT[1120]*source[685]+work.KKT[1121]*source[55];
result[686] = work.KKT[333]*source[374]+work.KKT[1124]*source[686]+work.KKT[1122]*source[55]+work.KKT[1125]*source[140];
result[687] = work.KKT[335]*source[375]+work.KKT[1126]*source[687]+work.KKT[1123]*source[55]+work.KKT[1127]*source[140];
result[688] = work.KKT[337]*source[376]+work.KKT[1128]*source[688]+work.KKT[1129]*source[56];
result[689] = work.KKT[339]*source[377]+work.KKT[1132]*source[689]+work.KKT[1130]*source[56]+work.KKT[1133]*source[143];
result[690] = work.KKT[341]*source[378]+work.KKT[1134]*source[690]+work.KKT[1131]*source[56]+work.KKT[1135]*source[143];
result[691] = work.KKT[343]*source[379]+work.KKT[1136]*source[691]+work.KKT[1137]*source[57];
result[692] = work.KKT[345]*source[380]+work.KKT[1140]*source[692]+work.KKT[1138]*source[57]+work.KKT[1141]*source[146];
result[693] = work.KKT[347]*source[381]+work.KKT[1142]*source[693]+work.KKT[1139]*source[57]+work.KKT[1143]*source[146];
result[694] = work.KKT[349]*source[382]+work.KKT[1144]*source[694]+work.KKT[1145]*source[58];
result[695] = work.KKT[351]*source[383]+work.KKT[1148]*source[695]+work.KKT[1146]*source[58]+work.KKT[1149]*source[149];
result[696] = work.KKT[353]*source[384]+work.KKT[1150]*source[696]+work.KKT[1147]*source[58]+work.KKT[1151]*source[149];
result[697] = work.KKT[355]*source[385]+work.KKT[1152]*source[697]+work.KKT[1153]*source[59];
result[698] = work.KKT[357]*source[386]+work.KKT[1156]*source[698]+work.KKT[1154]*source[59]+work.KKT[1157]*source[152];
result[699] = work.KKT[359]*source[387]+work.KKT[1158]*source[699]+work.KKT[1155]*source[59]+work.KKT[1159]*source[152];
result[700] = work.KKT[361]*source[388]+work.KKT[1160]*source[700]+work.KKT[1161]*source[60];
result[701] = work.KKT[363]*source[389]+work.KKT[1164]*source[701]+work.KKT[1162]*source[60]+work.KKT[1165]*source[155];
result[702] = work.KKT[365]*source[390]+work.KKT[1166]*source[702]+work.KKT[1163]*source[60]+work.KKT[1167]*source[155];
result[703] = work.KKT[367]*source[391]+work.KKT[1168]*source[703]+work.KKT[1169]*source[61];
result[704] = work.KKT[369]*source[392]+work.KKT[1172]*source[704]+work.KKT[1170]*source[61]+work.KKT[1173]*source[158];
result[705] = work.KKT[371]*source[393]+work.KKT[1174]*source[705]+work.KKT[1171]*source[61]+work.KKT[1175]*source[158];
result[706] = work.KKT[373]*source[394]+work.KKT[1176]*source[706]+work.KKT[1177]*source[62];
result[707] = work.KKT[375]*source[395]+work.KKT[1180]*source[707]+work.KKT[1178]*source[62]+work.KKT[1181]*source[161];
result[708] = work.KKT[377]*source[396]+work.KKT[1182]*source[708]+work.KKT[1179]*source[62]+work.KKT[1183]*source[161];
result[709] = work.KKT[379]*source[397]+work.KKT[1184]*source[709]+work.KKT[1185]*source[63];
result[710] = work.KKT[381]*source[398]+work.KKT[1188]*source[710]+work.KKT[1186]*source[63]+work.KKT[1189]*source[164];
result[711] = work.KKT[383]*source[399]+work.KKT[1190]*source[711]+work.KKT[1187]*source[63]+work.KKT[1191]*source[164];
result[712] = work.KKT[385]*source[400]+work.KKT[1192]*source[712]+work.KKT[1193]*source[64];
result[713] = work.KKT[387]*source[401]+work.KKT[1196]*source[713]+work.KKT[1194]*source[64]+work.KKT[1197]*source[167];
result[714] = work.KKT[389]*source[402]+work.KKT[1198]*source[714]+work.KKT[1195]*source[64]+work.KKT[1199]*source[167];
result[715] = work.KKT[391]*source[403]+work.KKT[1200]*source[715]+work.KKT[1201]*source[65];
result[716] = work.KKT[393]*source[404]+work.KKT[1204]*source[716]+work.KKT[1202]*source[65]+work.KKT[1205]*source[170];
result[717] = work.KKT[395]*source[405]+work.KKT[1206]*source[717]+work.KKT[1203]*source[65]+work.KKT[1207]*source[170];
result[718] = work.KKT[397]*source[406]+work.KKT[1208]*source[718]+work.KKT[1209]*source[66];
result[719] = work.KKT[399]*source[407]+work.KKT[1212]*source[719]+work.KKT[1210]*source[66]+work.KKT[1213]*source[173];
result[720] = work.KKT[401]*source[408]+work.KKT[1214]*source[720]+work.KKT[1211]*source[66]+work.KKT[1215]*source[173];
result[721] = work.KKT[403]*source[409]+work.KKT[1216]*source[721]+work.KKT[1217]*source[67];
result[722] = work.KKT[405]*source[410]+work.KKT[1220]*source[722]+work.KKT[1218]*source[67]+work.KKT[1221]*source[176];
result[723] = work.KKT[407]*source[411]+work.KKT[1222]*source[723]+work.KKT[1219]*source[67]+work.KKT[1223]*source[176];
result[724] = work.KKT[409]*source[412]+work.KKT[1224]*source[724]+work.KKT[1225]*source[68];
result[725] = work.KKT[411]*source[413]+work.KKT[1228]*source[725]+work.KKT[1226]*source[68]+work.KKT[1229]*source[179];
result[726] = work.KKT[413]*source[414]+work.KKT[1230]*source[726]+work.KKT[1227]*source[68]+work.KKT[1231]*source[179];
result[727] = work.KKT[415]*source[415]+work.KKT[1232]*source[727]+work.KKT[1233]*source[69];
result[728] = work.KKT[417]*source[416]+work.KKT[1236]*source[728]+work.KKT[1234]*source[69]+work.KKT[1237]*source[182];
result[729] = work.KKT[419]*source[417]+work.KKT[1238]*source[729]+work.KKT[1235]*source[69]+work.KKT[1239]*source[182];
result[730] = work.KKT[421]*source[418]+work.KKT[1240]*source[730]+work.KKT[1241]*source[70];
result[731] = work.KKT[423]*source[419]+work.KKT[1244]*source[731]+work.KKT[1242]*source[70]+work.KKT[1245]*source[185];
result[732] = work.KKT[425]*source[420]+work.KKT[1246]*source[732]+work.KKT[1243]*source[70]+work.KKT[1247]*source[185];
result[733] = work.KKT[427]*source[421]+work.KKT[1248]*source[733]+work.KKT[1249]*source[71];
result[734] = work.KKT[429]*source[422]+work.KKT[1252]*source[734]+work.KKT[1250]*source[71]+work.KKT[1253]*source[188];
result[735] = work.KKT[431]*source[423]+work.KKT[1254]*source[735]+work.KKT[1251]*source[71]+work.KKT[1255]*source[188];
result[736] = work.KKT[433]*source[424]+work.KKT[1256]*source[736]+work.KKT[1257]*source[72];
result[737] = work.KKT[435]*source[425]+work.KKT[1260]*source[737]+work.KKT[1258]*source[72]+work.KKT[1261]*source[191];
result[738] = work.KKT[437]*source[426]+work.KKT[1262]*source[738]+work.KKT[1259]*source[72]+work.KKT[1263]*source[191];
result[739] = work.KKT[439]*source[427]+work.KKT[1264]*source[739]+work.KKT[1265]*source[73];
result[740] = work.KKT[441]*source[428]+work.KKT[1268]*source[740]+work.KKT[1266]*source[73]+work.KKT[1269]*source[194];
result[741] = work.KKT[443]*source[429]+work.KKT[1270]*source[741]+work.KKT[1267]*source[73]+work.KKT[1271]*source[194];
result[742] = work.KKT[445]*source[430]+work.KKT[1272]*source[742]+work.KKT[1273]*source[74];
result[743] = work.KKT[447]*source[431]+work.KKT[1276]*source[743]+work.KKT[1274]*source[74]+work.KKT[1277]*source[197];
result[744] = work.KKT[449]*source[432]+work.KKT[1278]*source[744]+work.KKT[1275]*source[74]+work.KKT[1279]*source[197];
result[745] = work.KKT[451]*source[433]+work.KKT[1280]*source[745]+work.KKT[1281]*source[75];
result[746] = work.KKT[453]*source[434]+work.KKT[1284]*source[746]+work.KKT[1282]*source[75]+work.KKT[1285]*source[200];
result[747] = work.KKT[455]*source[435]+work.KKT[1286]*source[747]+work.KKT[1283]*source[75]+work.KKT[1287]*source[200];
result[748] = work.KKT[457]*source[436]+work.KKT[1288]*source[748]+work.KKT[1289]*source[76];
result[749] = work.KKT[459]*source[437]+work.KKT[1292]*source[749]+work.KKT[1290]*source[76]+work.KKT[1293]*source[203];
result[750] = work.KKT[461]*source[438]+work.KKT[1294]*source[750]+work.KKT[1291]*source[76]+work.KKT[1295]*source[203];
result[751] = work.KKT[463]*source[439]+work.KKT[1296]*source[751]+work.KKT[1297]*source[77];
result[752] = work.KKT[465]*source[440]+work.KKT[1300]*source[752]+work.KKT[1298]*source[77]+work.KKT[1301]*source[206];
result[753] = work.KKT[467]*source[441]+work.KKT[1302]*source[753]+work.KKT[1299]*source[77]+work.KKT[1303]*source[206];
result[754] = work.KKT[469]*source[442]+work.KKT[1306]*source[754]+work.KKT[1307]*source[78];
result[755] = work.KKT[471]*source[443]+work.KKT[1310]*source[755]+work.KKT[1308]*source[78]+work.KKT[1311]*source[132];
result[756] = work.KKT[473]*source[444]+work.KKT[1312]*source[756]+work.KKT[1309]*source[78]+work.KKT[1313]*source[132];
result[757] = work.KKT[475]*source[445]+work.KKT[1314]*source[757]+work.KKT[1315]*source[79];
result[758] = work.KKT[477]*source[446]+work.KKT[1318]*source[758]+work.KKT[1316]*source[79]+work.KKT[1319]*source[135];
result[759] = work.KKT[479]*source[447]+work.KKT[1320]*source[759]+work.KKT[1317]*source[79]+work.KKT[1321]*source[135];
result[760] = work.KKT[481]*source[448]+work.KKT[1322]*source[760]+work.KKT[1323]*source[80];
result[761] = work.KKT[483]*source[449]+work.KKT[1326]*source[761]+work.KKT[1324]*source[80]+work.KKT[1327]*source[138];
result[762] = work.KKT[485]*source[450]+work.KKT[1328]*source[762]+work.KKT[1325]*source[80]+work.KKT[1329]*source[138];
result[763] = work.KKT[487]*source[451]+work.KKT[1330]*source[763]+work.KKT[1331]*source[81];
result[764] = work.KKT[489]*source[452]+work.KKT[1334]*source[764]+work.KKT[1332]*source[81]+work.KKT[1335]*source[141];
result[765] = work.KKT[491]*source[453]+work.KKT[1336]*source[765]+work.KKT[1333]*source[81]+work.KKT[1337]*source[141];
result[766] = work.KKT[493]*source[454]+work.KKT[1338]*source[766]+work.KKT[1339]*source[82];
result[767] = work.KKT[495]*source[455]+work.KKT[1342]*source[767]+work.KKT[1340]*source[82]+work.KKT[1343]*source[144];
result[768] = work.KKT[497]*source[456]+work.KKT[1344]*source[768]+work.KKT[1341]*source[82]+work.KKT[1345]*source[144];
result[769] = work.KKT[499]*source[457]+work.KKT[1346]*source[769]+work.KKT[1347]*source[83];
result[770] = work.KKT[501]*source[458]+work.KKT[1350]*source[770]+work.KKT[1348]*source[83]+work.KKT[1351]*source[147];
result[771] = work.KKT[503]*source[459]+work.KKT[1352]*source[771]+work.KKT[1349]*source[83]+work.KKT[1353]*source[147];
result[772] = work.KKT[505]*source[460]+work.KKT[1354]*source[772]+work.KKT[1355]*source[84];
result[773] = work.KKT[507]*source[461]+work.KKT[1358]*source[773]+work.KKT[1356]*source[84]+work.KKT[1359]*source[150];
result[774] = work.KKT[509]*source[462]+work.KKT[1360]*source[774]+work.KKT[1357]*source[84]+work.KKT[1361]*source[150];
result[775] = work.KKT[511]*source[463]+work.KKT[1362]*source[775]+work.KKT[1363]*source[85];
result[776] = work.KKT[513]*source[464]+work.KKT[1366]*source[776]+work.KKT[1364]*source[85]+work.KKT[1367]*source[153];
result[777] = work.KKT[515]*source[465]+work.KKT[1368]*source[777]+work.KKT[1365]*source[85]+work.KKT[1369]*source[153];
result[778] = work.KKT[517]*source[466]+work.KKT[1370]*source[778]+work.KKT[1371]*source[86];
result[779] = work.KKT[519]*source[467]+work.KKT[1374]*source[779]+work.KKT[1372]*source[86]+work.KKT[1375]*source[156];
result[780] = work.KKT[521]*source[468]+work.KKT[1376]*source[780]+work.KKT[1373]*source[86]+work.KKT[1377]*source[156];
result[781] = work.KKT[523]*source[469]+work.KKT[1378]*source[781]+work.KKT[1379]*source[87];
result[782] = work.KKT[525]*source[470]+work.KKT[1382]*source[782]+work.KKT[1380]*source[87]+work.KKT[1383]*source[159];
result[783] = work.KKT[527]*source[471]+work.KKT[1384]*source[783]+work.KKT[1381]*source[87]+work.KKT[1385]*source[159];
result[784] = work.KKT[529]*source[472]+work.KKT[1386]*source[784]+work.KKT[1387]*source[88];
result[785] = work.KKT[531]*source[473]+work.KKT[1390]*source[785]+work.KKT[1388]*source[88]+work.KKT[1391]*source[162];
result[786] = work.KKT[533]*source[474]+work.KKT[1392]*source[786]+work.KKT[1389]*source[88]+work.KKT[1393]*source[162];
result[787] = work.KKT[535]*source[475]+work.KKT[1394]*source[787]+work.KKT[1395]*source[89];
result[788] = work.KKT[537]*source[476]+work.KKT[1398]*source[788]+work.KKT[1396]*source[89]+work.KKT[1399]*source[165];
result[789] = work.KKT[539]*source[477]+work.KKT[1400]*source[789]+work.KKT[1397]*source[89]+work.KKT[1401]*source[165];
result[790] = work.KKT[541]*source[478]+work.KKT[1402]*source[790]+work.KKT[1403]*source[90];
result[791] = work.KKT[543]*source[479]+work.KKT[1406]*source[791]+work.KKT[1404]*source[90]+work.KKT[1407]*source[168];
result[792] = work.KKT[545]*source[480]+work.KKT[1408]*source[792]+work.KKT[1405]*source[90]+work.KKT[1409]*source[168];
result[793] = work.KKT[547]*source[481]+work.KKT[1410]*source[793]+work.KKT[1411]*source[91];
result[794] = work.KKT[549]*source[482]+work.KKT[1414]*source[794]+work.KKT[1412]*source[91]+work.KKT[1415]*source[171];
result[795] = work.KKT[551]*source[483]+work.KKT[1416]*source[795]+work.KKT[1413]*source[91]+work.KKT[1417]*source[171];
result[796] = work.KKT[553]*source[484]+work.KKT[1418]*source[796]+work.KKT[1419]*source[92];
result[797] = work.KKT[555]*source[485]+work.KKT[1422]*source[797]+work.KKT[1420]*source[92]+work.KKT[1423]*source[174];
result[798] = work.KKT[557]*source[486]+work.KKT[1424]*source[798]+work.KKT[1421]*source[92]+work.KKT[1425]*source[174];
result[799] = work.KKT[559]*source[487]+work.KKT[1426]*source[799]+work.KKT[1427]*source[93];
result[800] = work.KKT[561]*source[488]+work.KKT[1430]*source[800]+work.KKT[1428]*source[93]+work.KKT[1431]*source[177];
result[801] = work.KKT[563]*source[489]+work.KKT[1432]*source[801]+work.KKT[1429]*source[93]+work.KKT[1433]*source[177];
result[802] = work.KKT[565]*source[490]+work.KKT[1434]*source[802]+work.KKT[1435]*source[94];
result[803] = work.KKT[567]*source[491]+work.KKT[1438]*source[803]+work.KKT[1436]*source[94]+work.KKT[1439]*source[180];
result[804] = work.KKT[569]*source[492]+work.KKT[1440]*source[804]+work.KKT[1437]*source[94]+work.KKT[1441]*source[180];
result[805] = work.KKT[571]*source[493]+work.KKT[1442]*source[805]+work.KKT[1443]*source[95];
result[806] = work.KKT[573]*source[494]+work.KKT[1446]*source[806]+work.KKT[1444]*source[95]+work.KKT[1447]*source[183];
result[807] = work.KKT[575]*source[495]+work.KKT[1448]*source[807]+work.KKT[1445]*source[95]+work.KKT[1449]*source[183];
result[808] = work.KKT[577]*source[496]+work.KKT[1450]*source[808]+work.KKT[1451]*source[96];
result[809] = work.KKT[579]*source[497]+work.KKT[1454]*source[809]+work.KKT[1452]*source[96]+work.KKT[1455]*source[186];
result[810] = work.KKT[581]*source[498]+work.KKT[1456]*source[810]+work.KKT[1453]*source[96]+work.KKT[1457]*source[186];
result[811] = work.KKT[583]*source[499]+work.KKT[1458]*source[811]+work.KKT[1459]*source[97];
result[812] = work.KKT[585]*source[500]+work.KKT[1462]*source[812]+work.KKT[1460]*source[97]+work.KKT[1463]*source[189];
result[813] = work.KKT[587]*source[501]+work.KKT[1464]*source[813]+work.KKT[1461]*source[97]+work.KKT[1465]*source[189];
result[814] = work.KKT[589]*source[502]+work.KKT[1466]*source[814]+work.KKT[1467]*source[98];
result[815] = work.KKT[591]*source[503]+work.KKT[1470]*source[815]+work.KKT[1468]*source[98]+work.KKT[1471]*source[192];
result[816] = work.KKT[593]*source[504]+work.KKT[1472]*source[816]+work.KKT[1469]*source[98]+work.KKT[1473]*source[192];
result[817] = work.KKT[595]*source[505]+work.KKT[1474]*source[817]+work.KKT[1475]*source[99];
result[818] = work.KKT[597]*source[506]+work.KKT[1478]*source[818]+work.KKT[1476]*source[99]+work.KKT[1479]*source[195];
result[819] = work.KKT[599]*source[507]+work.KKT[1480]*source[819]+work.KKT[1477]*source[99]+work.KKT[1481]*source[195];
result[820] = work.KKT[601]*source[508]+work.KKT[1482]*source[820]+work.KKT[1483]*source[100];
result[821] = work.KKT[603]*source[509]+work.KKT[1486]*source[821]+work.KKT[1484]*source[100]+work.KKT[1487]*source[198];
result[822] = work.KKT[605]*source[510]+work.KKT[1488]*source[822]+work.KKT[1485]*source[100]+work.KKT[1489]*source[198];
result[823] = work.KKT[607]*source[511]+work.KKT[1490]*source[823]+work.KKT[1491]*source[101];
result[824] = work.KKT[609]*source[512]+work.KKT[1494]*source[824]+work.KKT[1492]*source[101]+work.KKT[1495]*source[201];
result[825] = work.KKT[611]*source[513]+work.KKT[1496]*source[825]+work.KKT[1493]*source[101]+work.KKT[1497]*source[201];
result[826] = work.KKT[613]*source[514]+work.KKT[1498]*source[826]+work.KKT[1499]*source[102];
result[827] = work.KKT[615]*source[515]+work.KKT[1502]*source[827]+work.KKT[1500]*source[102]+work.KKT[1503]*source[204];
result[828] = work.KKT[617]*source[516]+work.KKT[1504]*source[828]+work.KKT[1501]*source[102]+work.KKT[1505]*source[204];
result[829] = work.KKT[619]*source[517]+work.KKT[1506]*source[829]+work.KKT[1507]*source[103];
result[830] = work.KKT[621]*source[518]+work.KKT[1510]*source[830]+work.KKT[1508]*source[103]+work.KKT[1511]*source[207];
result[831] = work.KKT[623]*source[519]+work.KKT[1512]*source[831]+work.KKT[1509]*source[103]+work.KKT[1513]*source[207];
result[832] = work.KKT[624]*source[130];
result[833] = work.KKT[625]*source[131];
result[834] = work.KKT[1517]*source[104]+work.KKT[1518]*source[132];
result[835] = work.KKT[627]*source[130]+work.KKT[1519]*source[131]+work.KKT[1520]*source[133];
result[836] = work.KKT[1527]*source[131]+work.KKT[1599]*source[132]+work.KKT[1598]*source[134];
result[837] = work.KKT[1600]*source[105]+work.KKT[1601]*source[132]+work.KKT[1602]*source[135];
result[838] = work.KKT[1529]*source[133]+work.KKT[1603]*source[134]+work.KKT[1531]*source[136];
result[839] = work.KKT[1619]*source[134]+work.KKT[1622]*source[135]+work.KKT[1623]*source[137];
result[840] = work.KKT[1605]*source[106]+work.KKT[1604]*source[135]+work.KKT[1606]*source[138];
result[841] = work.KKT[1532]*source[136]+work.KKT[1628]*source[137]+work.KKT[1534]*source[139];
result[842] = work.KKT[1624]*source[137]+work.KKT[1625]*source[138]+work.KKT[1626]*source[140];
result[843] = work.KKT[1630]*source[107]+work.KKT[1629]*source[138]+work.KKT[1631]*source[141];
result[844] = work.KKT[1535]*source[139]+work.KKT[1637]*source[140]+work.KKT[1537]*source[142];
result[845] = work.KKT[1633]*source[140]+work.KKT[1634]*source[141]+work.KKT[1635]*source[143];
result[846] = work.KKT[1639]*source[108]+work.KKT[1638]*source[141]+work.KKT[1640]*source[144];
result[847] = work.KKT[1538]*source[142]+work.KKT[1646]*source[143]+work.KKT[1540]*source[145];
result[848] = work.KKT[1642]*source[143]+work.KKT[1643]*source[144]+work.KKT[1644]*source[146];
result[849] = work.KKT[1648]*source[109]+work.KKT[1647]*source[144]+work.KKT[1649]*source[147];
result[850] = work.KKT[1541]*source[145]+work.KKT[1655]*source[146]+work.KKT[1543]*source[148];
result[851] = work.KKT[1651]*source[146]+work.KKT[1652]*source[147]+work.KKT[1653]*source[149];
result[852] = work.KKT[1657]*source[110]+work.KKT[1656]*source[147]+work.KKT[1658]*source[150];
result[853] = work.KKT[1544]*source[148]+work.KKT[1664]*source[149]+work.KKT[1546]*source[151];
result[854] = work.KKT[1660]*source[149]+work.KKT[1661]*source[150]+work.KKT[1662]*source[152];
result[855] = work.KKT[1666]*source[111]+work.KKT[1665]*source[150]+work.KKT[1667]*source[153];
result[856] = work.KKT[1547]*source[151]+work.KKT[1673]*source[152]+work.KKT[1549]*source[154];
result[857] = work.KKT[1669]*source[152]+work.KKT[1670]*source[153]+work.KKT[1671]*source[155];
result[858] = work.KKT[1675]*source[112]+work.KKT[1674]*source[153]+work.KKT[1676]*source[156];
result[859] = work.KKT[1550]*source[154]+work.KKT[1682]*source[155]+work.KKT[1552]*source[157];
result[860] = work.KKT[1678]*source[155]+work.KKT[1679]*source[156]+work.KKT[1680]*source[158];
result[861] = work.KKT[1684]*source[113]+work.KKT[1683]*source[156]+work.KKT[1685]*source[159];
result[862] = work.KKT[1553]*source[157]+work.KKT[1691]*source[158]+work.KKT[1555]*source[160];
result[863] = work.KKT[1687]*source[158]+work.KKT[1688]*source[159]+work.KKT[1689]*source[161];
result[864] = work.KKT[1693]*source[114]+work.KKT[1692]*source[159]+work.KKT[1694]*source[162];
result[865] = work.KKT[1556]*source[160]+work.KKT[1700]*source[161]+work.KKT[1558]*source[163];
result[866] = work.KKT[1696]*source[161]+work.KKT[1697]*source[162]+work.KKT[1698]*source[164];
result[867] = work.KKT[1702]*source[115]+work.KKT[1701]*source[162]+work.KKT[1703]*source[165];
result[868] = work.KKT[1559]*source[163]+work.KKT[1709]*source[164]+work.KKT[1561]*source[166];
result[869] = work.KKT[1705]*source[164]+work.KKT[1706]*source[165]+work.KKT[1707]*source[167];
result[870] = work.KKT[1711]*source[116]+work.KKT[1710]*source[165]+work.KKT[1712]*source[168];
result[871] = work.KKT[1562]*source[166]+work.KKT[1718]*source[167]+work.KKT[1564]*source[169];
result[872] = work.KKT[1714]*source[167]+work.KKT[1715]*source[168]+work.KKT[1716]*source[170];
result[873] = work.KKT[1720]*source[117]+work.KKT[1719]*source[168]+work.KKT[1721]*source[171];
result[874] = work.KKT[1565]*source[169]+work.KKT[1727]*source[170]+work.KKT[1567]*source[172];
result[875] = work.KKT[1723]*source[170]+work.KKT[1724]*source[171]+work.KKT[1725]*source[173];
result[876] = work.KKT[1729]*source[118]+work.KKT[1728]*source[171]+work.KKT[1730]*source[174];
result[877] = work.KKT[1568]*source[172]+work.KKT[1736]*source[173]+work.KKT[1570]*source[175];
result[878] = work.KKT[1732]*source[173]+work.KKT[1733]*source[174]+work.KKT[1734]*source[176];
result[879] = work.KKT[1738]*source[119]+work.KKT[1737]*source[174]+work.KKT[1739]*source[177];
result[880] = work.KKT[1571]*source[175]+work.KKT[1745]*source[176]+work.KKT[1573]*source[178];
result[881] = work.KKT[1741]*source[176]+work.KKT[1742]*source[177]+work.KKT[1743]*source[179];
result[882] = work.KKT[1747]*source[120]+work.KKT[1746]*source[177]+work.KKT[1748]*source[180];
result[883] = work.KKT[1574]*source[178]+work.KKT[1754]*source[179]+work.KKT[1576]*source[181];
result[884] = work.KKT[1750]*source[179]+work.KKT[1751]*source[180]+work.KKT[1752]*source[182];
result[885] = work.KKT[1756]*source[121]+work.KKT[1755]*source[180]+work.KKT[1757]*source[183];
result[886] = work.KKT[1577]*source[181]+work.KKT[1763]*source[182]+work.KKT[1579]*source[184];
result[887] = work.KKT[1759]*source[182]+work.KKT[1760]*source[183]+work.KKT[1761]*source[185];
result[888] = work.KKT[1765]*source[122]+work.KKT[1764]*source[183]+work.KKT[1766]*source[186];
result[889] = work.KKT[1580]*source[184]+work.KKT[1772]*source[185]+work.KKT[1582]*source[187];
result[890] = work.KKT[1768]*source[185]+work.KKT[1769]*source[186]+work.KKT[1770]*source[188];
result[891] = work.KKT[1774]*source[123]+work.KKT[1773]*source[186]+work.KKT[1775]*source[189];
result[892] = work.KKT[1583]*source[187]+work.KKT[1781]*source[188]+work.KKT[1585]*source[190];
result[893] = work.KKT[1777]*source[188]+work.KKT[1778]*source[189]+work.KKT[1779]*source[191];
result[894] = work.KKT[1783]*source[124]+work.KKT[1782]*source[189]+work.KKT[1784]*source[192];
result[895] = work.KKT[1586]*source[190]+work.KKT[1790]*source[191]+work.KKT[1588]*source[193];
result[896] = work.KKT[1786]*source[191]+work.KKT[1787]*source[192]+work.KKT[1788]*source[194];
result[897] = work.KKT[1792]*source[125]+work.KKT[1791]*source[192]+work.KKT[1793]*source[195];
result[898] = work.KKT[1589]*source[193]+work.KKT[1799]*source[194]+work.KKT[1591]*source[196];
result[899] = work.KKT[1795]*source[194]+work.KKT[1796]*source[195]+work.KKT[1797]*source[197];
result[900] = work.KKT[1801]*source[126]+work.KKT[1800]*source[195]+work.KKT[1802]*source[198];
result[901] = work.KKT[1592]*source[196]+work.KKT[1806]*source[197]+work.KKT[1595]*source[199];
result[902] = work.KKT[1807]*source[197]+work.KKT[1808]*source[198]+work.KKT[1809]*source[200];
result[903] = work.KKT[1612]*source[127]+work.KKT[1613]*source[198]+work.KKT[1611]*source[201];
result[904] = work.KKT[1594]*source[199]+work.KKT[1617]*source[200]+work.KKT[1597]*source[202];
result[905] = work.KKT[1616]*source[200]+work.KKT[1615]*source[201]+work.KKT[1614]*source[203];
result[906] = work.KKT[1607]*source[128]+work.KKT[1609]*source[201]+work.KKT[1608]*source[204];
result[907] = work.KKT[1521]*source[202]+work.KKT[1522]*source[203]+work.KKT[629]*source[205];
result[908] = work.KKT[1524]*source[203]+work.KKT[1523]*source[204]+work.KKT[1305]*source[206];
result[909] = work.KKT[1516]*source[129]+work.KKT[1525]*source[204]+work.KKT[1515]*source[207];
}
double check_residual(double *target, double *multiplicand) {
/* Returns the squared 2-norm of lhs - A*rhs. */
/* Reuses v to find the residual. */
int i;
double residual;
residual = 0;
matrix_multiply(work.v, multiplicand);
for (i = 0; i < 208; i++) {
residual += (target[i] - work.v[i])*(target[i] - work.v[i]);
}
return residual;
}
void fill_KKT(void) {
work.KKT[626] = 2*params.Q[0];
work.KKT[1526] = 2*params.Q[1];
work.KKT[1620] = 2*params.Q[2];
work.KKT[1528] = 2*params.Q[0];
work.KKT[1618] = 2*params.Q[1];
work.KKT[1621] = 2*params.Q[2];
work.KKT[1530] = 2*params.Q[0];
work.KKT[1627] = 2*params.Q[1];
work.KKT[1632] = 2*params.Q[2];
work.KKT[1533] = 2*params.Q[0];
work.KKT[1636] = 2*params.Q[1];
work.KKT[1641] = 2*params.Q[2];
work.KKT[1536] = 2*params.Q[0];
work.KKT[1645] = 2*params.Q[1];
work.KKT[1650] = 2*params.Q[2];
work.KKT[1539] = 2*params.Q[0];
work.KKT[1654] = 2*params.Q[1];
work.KKT[1659] = 2*params.Q[2];
work.KKT[1542] = 2*params.Q[0];
work.KKT[1663] = 2*params.Q[1];
work.KKT[1668] = 2*params.Q[2];
work.KKT[1545] = 2*params.Q[0];
work.KKT[1672] = 2*params.Q[1];
work.KKT[1677] = 2*params.Q[2];
work.KKT[1548] = 2*params.Q[0];
work.KKT[1681] = 2*params.Q[1];
work.KKT[1686] = 2*params.Q[2];
work.KKT[1551] = 2*params.Q[0];
work.KKT[1690] = 2*params.Q[1];
work.KKT[1695] = 2*params.Q[2];
work.KKT[1554] = 2*params.Q[0];
work.KKT[1699] = 2*params.Q[1];
work.KKT[1704] = 2*params.Q[2];
work.KKT[1557] = 2*params.Q[0];
work.KKT[1708] = 2*params.Q[1];
work.KKT[1713] = 2*params.Q[2];
work.KKT[1560] = 2*params.Q[0];
work.KKT[1717] = 2*params.Q[1];
work.KKT[1722] = 2*params.Q[2];
work.KKT[1563] = 2*params.Q[0];
work.KKT[1726] = 2*params.Q[1];
work.KKT[1731] = 2*params.Q[2];
work.KKT[1566] = 2*params.Q[0];
work.KKT[1735] = 2*params.Q[1];
work.KKT[1740] = 2*params.Q[2];
work.KKT[1569] = 2*params.Q[0];
work.KKT[1744] = 2*params.Q[1];
work.KKT[1749] = 2*params.Q[2];
work.KKT[1572] = 2*params.Q[0];
work.KKT[1753] = 2*params.Q[1];
work.KKT[1758] = 2*params.Q[2];
work.KKT[1575] = 2*params.Q[0];
work.KKT[1762] = 2*params.Q[1];
work.KKT[1767] = 2*params.Q[2];
work.KKT[1578] = 2*params.Q[0];
work.KKT[1771] = 2*params.Q[1];
work.KKT[1776] = 2*params.Q[2];
work.KKT[1581] = 2*params.Q[0];
work.KKT[1780] = 2*params.Q[1];
work.KKT[1785] = 2*params.Q[2];
work.KKT[1584] = 2*params.Q[0];
work.KKT[1789] = 2*params.Q[1];
work.KKT[1794] = 2*params.Q[2];
work.KKT[1587] = 2*params.Q[0];
work.KKT[1798] = 2*params.Q[1];
work.KKT[1803] = 2*params.Q[2];
work.KKT[1590] = 2*params.Q[0];
work.KKT[1810] = 2*params.Q[1];
work.KKT[1811] = 2*params.Q[2];
work.KKT[1593] = 2*params.Q[0];
work.KKT[1812] = 2*params.Q[1];
work.KKT[1805] = 2*params.Q[2];
work.KKT[1596] = 2*params.Q[0];
work.KKT[1804] = 2*params.Q[1];
work.KKT[1610] = 2*params.Q[2];
work.KKT[628] = 2*params.Q_last[0];
work.KKT[1304] = 2*params.Q_last[1];
work.KKT[1514] = 2*params.Q_last[2];
work.KKT[0] = work.s_inv_z[0];
work.KKT[2] = work.s_inv_z[1];
work.KKT[4] = work.s_inv_z[2];
work.KKT[6] = work.s_inv_z[3];
work.KKT[8] = work.s_inv_z[4];
work.KKT[10] = work.s_inv_z[5];
work.KKT[12] = work.s_inv_z[6];
work.KKT[14] = work.s_inv_z[7];
work.KKT[16] = work.s_inv_z[8];
work.KKT[18] = work.s_inv_z[9];
work.KKT[20] = work.s_inv_z[10];
work.KKT[22] = work.s_inv_z[11];
work.KKT[24] = work.s_inv_z[12];
work.KKT[26] = work.s_inv_z[13];
work.KKT[28] = work.s_inv_z[14];
work.KKT[30] = work.s_inv_z[15];
work.KKT[32] = work.s_inv_z[16];
work.KKT[34] = work.s_inv_z[17];
work.KKT[36] = work.s_inv_z[18];
work.KKT[38] = work.s_inv_z[19];
work.KKT[40] = work.s_inv_z[20];
work.KKT[42] = work.s_inv_z[21];
work.KKT[44] = work.s_inv_z[22];
work.KKT[46] = work.s_inv_z[23];
work.KKT[48] = work.s_inv_z[24];
work.KKT[50] = work.s_inv_z[25];
work.KKT[52] = work.s_inv_z[26];
work.KKT[54] = work.s_inv_z[27];
work.KKT[56] = work.s_inv_z[28];
work.KKT[58] = work.s_inv_z[29];
work.KKT[60] = work.s_inv_z[30];
work.KKT[62] = work.s_inv_z[31];
work.KKT[64] = work.s_inv_z[32];
work.KKT[66] = work.s_inv_z[33];
work.KKT[68] = work.s_inv_z[34];
work.KKT[70] = work.s_inv_z[35];
work.KKT[72] = work.s_inv_z[36];
work.KKT[74] = work.s_inv_z[37];
work.KKT[76] = work.s_inv_z[38];
work.KKT[78] = work.s_inv_z[39];
work.KKT[80] = work.s_inv_z[40];
work.KKT[82] = work.s_inv_z[41];
work.KKT[84] = work.s_inv_z[42];
work.KKT[86] = work.s_inv_z[43];
work.KKT[88] = work.s_inv_z[44];
work.KKT[90] = work.s_inv_z[45];
work.KKT[92] = work.s_inv_z[46];
work.KKT[94] = work.s_inv_z[47];
work.KKT[96] = work.s_inv_z[48];
work.KKT[98] = work.s_inv_z[49];
work.KKT[100] = work.s_inv_z[50];
work.KKT[102] = work.s_inv_z[51];
work.KKT[104] = work.s_inv_z[52];
work.KKT[106] = work.s_inv_z[53];
work.KKT[108] = work.s_inv_z[54];
work.KKT[110] = work.s_inv_z[55];
work.KKT[112] = work.s_inv_z[56];
work.KKT[114] = work.s_inv_z[57];
work.KKT[116] = work.s_inv_z[58];
work.KKT[118] = work.s_inv_z[59];
work.KKT[120] = work.s_inv_z[60];
work.KKT[122] = work.s_inv_z[61];
work.KKT[124] = work.s_inv_z[62];
work.KKT[126] = work.s_inv_z[63];
work.KKT[128] = work.s_inv_z[64];
work.KKT[130] = work.s_inv_z[65];
work.KKT[132] = work.s_inv_z[66];
work.KKT[134] = work.s_inv_z[67];
work.KKT[136] = work.s_inv_z[68];
work.KKT[138] = work.s_inv_z[69];
work.KKT[140] = work.s_inv_z[70];
work.KKT[142] = work.s_inv_z[71];
work.KKT[144] = work.s_inv_z[72];
work.KKT[146] = work.s_inv_z[73];
work.KKT[148] = work.s_inv_z[74];
work.KKT[150] = work.s_inv_z[75];
work.KKT[152] = work.s_inv_z[76];
work.KKT[154] = work.s_inv_z[77];
work.KKT[156] = work.s_inv_z[78];
work.KKT[158] = work.s_inv_z[79];
work.KKT[160] = work.s_inv_z[80];
work.KKT[162] = work.s_inv_z[81];
work.KKT[164] = work.s_inv_z[82];
work.KKT[166] = work.s_inv_z[83];
work.KKT[168] = work.s_inv_z[84];
work.KKT[170] = work.s_inv_z[85];
work.KKT[172] = work.s_inv_z[86];
work.KKT[174] = work.s_inv_z[87];
work.KKT[176] = work.s_inv_z[88];
work.KKT[178] = work.s_inv_z[89];
work.KKT[180] = work.s_inv_z[90];
work.KKT[182] = work.s_inv_z[91];
work.KKT[184] = work.s_inv_z[92];
work.KKT[186] = work.s_inv_z[93];
work.KKT[188] = work.s_inv_z[94];
work.KKT[190] = work.s_inv_z[95];
work.KKT[192] = work.s_inv_z[96];
work.KKT[194] = work.s_inv_z[97];
work.KKT[196] = work.s_inv_z[98];
work.KKT[198] = work.s_inv_z[99];
work.KKT[200] = work.s_inv_z[100];
work.KKT[202] = work.s_inv_z[101];
work.KKT[204] = work.s_inv_z[102];
work.KKT[206] = work.s_inv_z[103];
work.KKT[208] = work.s_inv_z[104];
work.KKT[210] = work.s_inv_z[105];
work.KKT[212] = work.s_inv_z[106];
work.KKT[214] = work.s_inv_z[107];
work.KKT[216] = work.s_inv_z[108];
work.KKT[218] = work.s_inv_z[109];
work.KKT[220] = work.s_inv_z[110];
work.KKT[222] = work.s_inv_z[111];
work.KKT[224] = work.s_inv_z[112];
work.KKT[226] = work.s_inv_z[113];
work.KKT[228] = work.s_inv_z[114];
work.KKT[230] = work.s_inv_z[115];
work.KKT[232] = work.s_inv_z[116];
work.KKT[234] = work.s_inv_z[117];
work.KKT[236] = work.s_inv_z[118];
work.KKT[238] = work.s_inv_z[119];
work.KKT[240] = work.s_inv_z[120];
work.KKT[242] = work.s_inv_z[121];
work.KKT[244] = work.s_inv_z[122];
work.KKT[246] = work.s_inv_z[123];
work.KKT[248] = work.s_inv_z[124];
work.KKT[250] = work.s_inv_z[125];
work.KKT[252] = work.s_inv_z[126];
work.KKT[254] = work.s_inv_z[127];
work.KKT[256] = work.s_inv_z[128];
work.KKT[258] = work.s_inv_z[129];
work.KKT[260] = work.s_inv_z[130];
work.KKT[262] = work.s_inv_z[131];
work.KKT[264] = work.s_inv_z[132];
work.KKT[266] = work.s_inv_z[133];
work.KKT[268] = work.s_inv_z[134];
work.KKT[270] = work.s_inv_z[135];
work.KKT[272] = work.s_inv_z[136];
work.KKT[274] = work.s_inv_z[137];
work.KKT[276] = work.s_inv_z[138];
work.KKT[278] = work.s_inv_z[139];
work.KKT[280] = work.s_inv_z[140];
work.KKT[282] = work.s_inv_z[141];
work.KKT[284] = work.s_inv_z[142];
work.KKT[286] = work.s_inv_z[143];
work.KKT[288] = work.s_inv_z[144];
work.KKT[290] = work.s_inv_z[145];
work.KKT[292] = work.s_inv_z[146];
work.KKT[294] = work.s_inv_z[147];
work.KKT[296] = work.s_inv_z[148];
work.KKT[298] = work.s_inv_z[149];
work.KKT[300] = work.s_inv_z[150];
work.KKT[302] = work.s_inv_z[151];
work.KKT[304] = work.s_inv_z[152];
work.KKT[306] = work.s_inv_z[153];
work.KKT[308] = work.s_inv_z[154];
work.KKT[310] = work.s_inv_z[155];
work.KKT[312] = work.s_inv_z[156];
work.KKT[314] = work.s_inv_z[157];
work.KKT[316] = work.s_inv_z[158];
work.KKT[318] = work.s_inv_z[159];
work.KKT[320] = work.s_inv_z[160];
work.KKT[322] = work.s_inv_z[161];
work.KKT[324] = work.s_inv_z[162];
work.KKT[326] = work.s_inv_z[163];
work.KKT[328] = work.s_inv_z[164];
work.KKT[330] = work.s_inv_z[165];
work.KKT[332] = work.s_inv_z[166];
work.KKT[334] = work.s_inv_z[167];
work.KKT[336] = work.s_inv_z[168];
work.KKT[338] = work.s_inv_z[169];
work.KKT[340] = work.s_inv_z[170];
work.KKT[342] = work.s_inv_z[171];
work.KKT[344] = work.s_inv_z[172];
work.KKT[346] = work.s_inv_z[173];
work.KKT[348] = work.s_inv_z[174];
work.KKT[350] = work.s_inv_z[175];
work.KKT[352] = work.s_inv_z[176];
work.KKT[354] = work.s_inv_z[177];
work.KKT[356] = work.s_inv_z[178];
work.KKT[358] = work.s_inv_z[179];
work.KKT[360] = work.s_inv_z[180];
work.KKT[362] = work.s_inv_z[181];
work.KKT[364] = work.s_inv_z[182];
work.KKT[366] = work.s_inv_z[183];
work.KKT[368] = work.s_inv_z[184];
work.KKT[370] = work.s_inv_z[185];
work.KKT[372] = work.s_inv_z[186];
work.KKT[374] = work.s_inv_z[187];
work.KKT[376] = work.s_inv_z[188];
work.KKT[378] = work.s_inv_z[189];
work.KKT[380] = work.s_inv_z[190];
work.KKT[382] = work.s_inv_z[191];
work.KKT[384] = work.s_inv_z[192];
work.KKT[386] = work.s_inv_z[193];
work.KKT[388] = work.s_inv_z[194];
work.KKT[390] = work.s_inv_z[195];
work.KKT[392] = work.s_inv_z[196];
work.KKT[394] = work.s_inv_z[197];
work.KKT[396] = work.s_inv_z[198];
work.KKT[398] = work.s_inv_z[199];
work.KKT[400] = work.s_inv_z[200];
work.KKT[402] = work.s_inv_z[201];
work.KKT[404] = work.s_inv_z[202];
work.KKT[406] = work.s_inv_z[203];
work.KKT[408] = work.s_inv_z[204];
work.KKT[410] = work.s_inv_z[205];
work.KKT[412] = work.s_inv_z[206];
work.KKT[414] = work.s_inv_z[207];
work.KKT[416] = work.s_inv_z[208];
work.KKT[418] = work.s_inv_z[209];
work.KKT[420] = work.s_inv_z[210];
work.KKT[422] = work.s_inv_z[211];
work.KKT[424] = work.s_inv_z[212];
work.KKT[426] = work.s_inv_z[213];
work.KKT[428] = work.s_inv_z[214];
work.KKT[430] = work.s_inv_z[215];
work.KKT[432] = work.s_inv_z[216];
work.KKT[434] = work.s_inv_z[217];
work.KKT[436] = work.s_inv_z[218];
work.KKT[438] = work.s_inv_z[219];
work.KKT[440] = work.s_inv_z[220];
work.KKT[442] = work.s_inv_z[221];
work.KKT[444] = work.s_inv_z[222];
work.KKT[446] = work.s_inv_z[223];
work.KKT[448] = work.s_inv_z[224];
work.KKT[450] = work.s_inv_z[225];
work.KKT[452] = work.s_inv_z[226];
work.KKT[454] = work.s_inv_z[227];
work.KKT[456] = work.s_inv_z[228];
work.KKT[458] = work.s_inv_z[229];
work.KKT[460] = work.s_inv_z[230];
work.KKT[462] = work.s_inv_z[231];
work.KKT[464] = work.s_inv_z[232];
work.KKT[466] = work.s_inv_z[233];
work.KKT[468] = work.s_inv_z[234];
work.KKT[470] = work.s_inv_z[235];
work.KKT[472] = work.s_inv_z[236];
work.KKT[474] = work.s_inv_z[237];
work.KKT[476] = work.s_inv_z[238];
work.KKT[478] = work.s_inv_z[239];
work.KKT[480] = work.s_inv_z[240];
work.KKT[482] = work.s_inv_z[241];
work.KKT[484] = work.s_inv_z[242];
work.KKT[486] = work.s_inv_z[243];
work.KKT[488] = work.s_inv_z[244];
work.KKT[490] = work.s_inv_z[245];
work.KKT[492] = work.s_inv_z[246];
work.KKT[494] = work.s_inv_z[247];
work.KKT[496] = work.s_inv_z[248];
work.KKT[498] = work.s_inv_z[249];
work.KKT[500] = work.s_inv_z[250];
work.KKT[502] = work.s_inv_z[251];
work.KKT[504] = work.s_inv_z[252];
work.KKT[506] = work.s_inv_z[253];
work.KKT[508] = work.s_inv_z[254];
work.KKT[510] = work.s_inv_z[255];
work.KKT[512] = work.s_inv_z[256];
work.KKT[514] = work.s_inv_z[257];
work.KKT[516] = work.s_inv_z[258];
work.KKT[518] = work.s_inv_z[259];
work.KKT[520] = work.s_inv_z[260];
work.KKT[522] = work.s_inv_z[261];
work.KKT[524] = work.s_inv_z[262];
work.KKT[526] = work.s_inv_z[263];
work.KKT[528] = work.s_inv_z[264];
work.KKT[530] = work.s_inv_z[265];
work.KKT[532] = work.s_inv_z[266];
work.KKT[534] = work.s_inv_z[267];
work.KKT[536] = work.s_inv_z[268];
work.KKT[538] = work.s_inv_z[269];
work.KKT[540] = work.s_inv_z[270];
work.KKT[542] = work.s_inv_z[271];
work.KKT[544] = work.s_inv_z[272];
work.KKT[546] = work.s_inv_z[273];
work.KKT[548] = work.s_inv_z[274];
work.KKT[550] = work.s_inv_z[275];
work.KKT[552] = work.s_inv_z[276];
work.KKT[554] = work.s_inv_z[277];
work.KKT[556] = work.s_inv_z[278];
work.KKT[558] = work.s_inv_z[279];
work.KKT[560] = work.s_inv_z[280];
work.KKT[562] = work.s_inv_z[281];
work.KKT[564] = work.s_inv_z[282];
work.KKT[566] = work.s_inv_z[283];
work.KKT[568] = work.s_inv_z[284];
work.KKT[570] = work.s_inv_z[285];
work.KKT[572] = work.s_inv_z[286];
work.KKT[574] = work.s_inv_z[287];
work.KKT[576] = work.s_inv_z[288];
work.KKT[578] = work.s_inv_z[289];
work.KKT[580] = work.s_inv_z[290];
work.KKT[582] = work.s_inv_z[291];
work.KKT[584] = work.s_inv_z[292];
work.KKT[586] = work.s_inv_z[293];
work.KKT[588] = work.s_inv_z[294];
work.KKT[590] = work.s_inv_z[295];
work.KKT[592] = work.s_inv_z[296];
work.KKT[594] = work.s_inv_z[297];
work.KKT[596] = work.s_inv_z[298];
work.KKT[598] = work.s_inv_z[299];
work.KKT[600] = work.s_inv_z[300];
work.KKT[602] = work.s_inv_z[301];
work.KKT[604] = work.s_inv_z[302];
work.KKT[606] = work.s_inv_z[303];
work.KKT[608] = work.s_inv_z[304];
work.KKT[610] = work.s_inv_z[305];
work.KKT[612] = work.s_inv_z[306];
work.KKT[614] = work.s_inv_z[307];
work.KKT[616] = work.s_inv_z[308];
work.KKT[618] = work.s_inv_z[309];
work.KKT[620] = work.s_inv_z[310];
work.KKT[622] = work.s_inv_z[311];
work.KKT[1] = 1;
work.KKT[3] = 1;
work.KKT[5] = 1;
work.KKT[7] = 1;
work.KKT[9] = 1;
work.KKT[11] = 1;
work.KKT[13] = 1;
work.KKT[15] = 1;
work.KKT[17] = 1;
work.KKT[19] = 1;
work.KKT[21] = 1;
work.KKT[23] = 1;
work.KKT[25] = 1;
work.KKT[27] = 1;
work.KKT[29] = 1;
work.KKT[31] = 1;
work.KKT[33] = 1;
work.KKT[35] = 1;
work.KKT[37] = 1;
work.KKT[39] = 1;
work.KKT[41] = 1;
work.KKT[43] = 1;
work.KKT[45] = 1;
work.KKT[47] = 1;
work.KKT[49] = 1;
work.KKT[51] = 1;
work.KKT[53] = 1;
work.KKT[55] = 1;
work.KKT[57] = 1;
work.KKT[59] = 1;
work.KKT[61] = 1;
work.KKT[63] = 1;
work.KKT[65] = 1;
work.KKT[67] = 1;
work.KKT[69] = 1;
work.KKT[71] = 1;
work.KKT[73] = 1;
work.KKT[75] = 1;
work.KKT[77] = 1;
work.KKT[79] = 1;
work.KKT[81] = 1;
work.KKT[83] = 1;
work.KKT[85] = 1;
work.KKT[87] = 1;
work.KKT[89] = 1;
work.KKT[91] = 1;
work.KKT[93] = 1;
work.KKT[95] = 1;
work.KKT[97] = 1;
work.KKT[99] = 1;
work.KKT[101] = 1;
work.KKT[103] = 1;
work.KKT[105] = 1;
work.KKT[107] = 1;
work.KKT[109] = 1;
work.KKT[111] = 1;
work.KKT[113] = 1;
work.KKT[115] = 1;
work.KKT[117] = 1;
work.KKT[119] = 1;
work.KKT[121] = 1;
work.KKT[123] = 1;
work.KKT[125] = 1;
work.KKT[127] = 1;
work.KKT[129] = 1;
work.KKT[131] = 1;
work.KKT[133] = 1;
work.KKT[135] = 1;
work.KKT[137] = 1;
work.KKT[139] = 1;
work.KKT[141] = 1;
work.KKT[143] = 1;
work.KKT[145] = 1;
work.KKT[147] = 1;
work.KKT[149] = 1;
work.KKT[151] = 1;
work.KKT[153] = 1;
work.KKT[155] = 1;
work.KKT[157] = 1;
work.KKT[159] = 1;
work.KKT[161] = 1;
work.KKT[163] = 1;
work.KKT[165] = 1;
work.KKT[167] = 1;
work.KKT[169] = 1;
work.KKT[171] = 1;
work.KKT[173] = 1;
work.KKT[175] = 1;
work.KKT[177] = 1;
work.KKT[179] = 1;
work.KKT[181] = 1;
work.KKT[183] = 1;
work.KKT[185] = 1;
work.KKT[187] = 1;
work.KKT[189] = 1;
work.KKT[191] = 1;
work.KKT[193] = 1;
work.KKT[195] = 1;
work.KKT[197] = 1;
work.KKT[199] = 1;
work.KKT[201] = 1;
work.KKT[203] = 1;
work.KKT[205] = 1;
work.KKT[207] = 1;
work.KKT[209] = 1;
work.KKT[211] = 1;
work.KKT[213] = 1;
work.KKT[215] = 1;
work.KKT[217] = 1;
work.KKT[219] = 1;
work.KKT[221] = 1;
work.KKT[223] = 1;
work.KKT[225] = 1;
work.KKT[227] = 1;
work.KKT[229] = 1;
work.KKT[231] = 1;
work.KKT[233] = 1;
work.KKT[235] = 1;
work.KKT[237] = 1;
work.KKT[239] = 1;
work.KKT[241] = 1;
work.KKT[243] = 1;
work.KKT[245] = 1;
work.KKT[247] = 1;
work.KKT[249] = 1;
work.KKT[251] = 1;
work.KKT[253] = 1;
work.KKT[255] = 1;
work.KKT[257] = 1;
work.KKT[259] = 1;
work.KKT[261] = 1;
work.KKT[263] = 1;
work.KKT[265] = 1;
work.KKT[267] = 1;
work.KKT[269] = 1;
work.KKT[271] = 1;
work.KKT[273] = 1;
work.KKT[275] = 1;
work.KKT[277] = 1;
work.KKT[279] = 1;
work.KKT[281] = 1;
work.KKT[283] = 1;
work.KKT[285] = 1;
work.KKT[287] = 1;
work.KKT[289] = 1;
work.KKT[291] = 1;
work.KKT[293] = 1;
work.KKT[295] = 1;
work.KKT[297] = 1;
work.KKT[299] = 1;
work.KKT[301] = 1;
work.KKT[303] = 1;
work.KKT[305] = 1;
work.KKT[307] = 1;
work.KKT[309] = 1;
work.KKT[311] = 1;
work.KKT[313] = 1;
work.KKT[315] = 1;
work.KKT[317] = 1;
work.KKT[319] = 1;
work.KKT[321] = 1;
work.KKT[323] = 1;
work.KKT[325] = 1;
work.KKT[327] = 1;
work.KKT[329] = 1;
work.KKT[331] = 1;
work.KKT[333] = 1;
work.KKT[335] = 1;
work.KKT[337] = 1;
work.KKT[339] = 1;
work.KKT[341] = 1;
work.KKT[343] = 1;
work.KKT[345] = 1;
work.KKT[347] = 1;
work.KKT[349] = 1;
work.KKT[351] = 1;
work.KKT[353] = 1;
work.KKT[355] = 1;
work.KKT[357] = 1;
work.KKT[359] = 1;
work.KKT[361] = 1;
work.KKT[363] = 1;
work.KKT[365] = 1;
work.KKT[367] = 1;
work.KKT[369] = 1;
work.KKT[371] = 1;
work.KKT[373] = 1;
work.KKT[375] = 1;
work.KKT[377] = 1;
work.KKT[379] = 1;
work.KKT[381] = 1;
work.KKT[383] = 1;
work.KKT[385] = 1;
work.KKT[387] = 1;
work.KKT[389] = 1;
work.KKT[391] = 1;
work.KKT[393] = 1;
work.KKT[395] = 1;
work.KKT[397] = 1;
work.KKT[399] = 1;
work.KKT[401] = 1;
work.KKT[403] = 1;
work.KKT[405] = 1;
work.KKT[407] = 1;
work.KKT[409] = 1;
work.KKT[411] = 1;
work.KKT[413] = 1;
work.KKT[415] = 1;
work.KKT[417] = 1;
work.KKT[419] = 1;
work.KKT[421] = 1;
work.KKT[423] = 1;
work.KKT[425] = 1;
work.KKT[427] = 1;
work.KKT[429] = 1;
work.KKT[431] = 1;
work.KKT[433] = 1;
work.KKT[435] = 1;
work.KKT[437] = 1;
work.KKT[439] = 1;
work.KKT[441] = 1;
work.KKT[443] = 1;
work.KKT[445] = 1;
work.KKT[447] = 1;
work.KKT[449] = 1;
work.KKT[451] = 1;
work.KKT[453] = 1;
work.KKT[455] = 1;
work.KKT[457] = 1;
work.KKT[459] = 1;
work.KKT[461] = 1;
work.KKT[463] = 1;
work.KKT[465] = 1;
work.KKT[467] = 1;
work.KKT[469] = 1;
work.KKT[471] = 1;
work.KKT[473] = 1;
work.KKT[475] = 1;
work.KKT[477] = 1;
work.KKT[479] = 1;
work.KKT[481] = 1;
work.KKT[483] = 1;
work.KKT[485] = 1;
work.KKT[487] = 1;
work.KKT[489] = 1;
work.KKT[491] = 1;
work.KKT[493] = 1;
work.KKT[495] = 1;
work.KKT[497] = 1;
work.KKT[499] = 1;
work.KKT[501] = 1;
work.KKT[503] = 1;
work.KKT[505] = 1;
work.KKT[507] = 1;
work.KKT[509] = 1;
work.KKT[511] = 1;
work.KKT[513] = 1;
work.KKT[515] = 1;
work.KKT[517] = 1;
work.KKT[519] = 1;
work.KKT[521] = 1;
work.KKT[523] = 1;
work.KKT[525] = 1;
work.KKT[527] = 1;
work.KKT[529] = 1;
work.KKT[531] = 1;
work.KKT[533] = 1;
work.KKT[535] = 1;
work.KKT[537] = 1;
work.KKT[539] = 1;
work.KKT[541] = 1;
work.KKT[543] = 1;
work.KKT[545] = 1;
work.KKT[547] = 1;
work.KKT[549] = 1;
work.KKT[551] = 1;
work.KKT[553] = 1;
work.KKT[555] = 1;
work.KKT[557] = 1;
work.KKT[559] = 1;
work.KKT[561] = 1;
work.KKT[563] = 1;
work.KKT[565] = 1;
work.KKT[567] = 1;
work.KKT[569] = 1;
work.KKT[571] = 1;
work.KKT[573] = 1;
work.KKT[575] = 1;
work.KKT[577] = 1;
work.KKT[579] = 1;
work.KKT[581] = 1;
work.KKT[583] = 1;
work.KKT[585] = 1;
work.KKT[587] = 1;
work.KKT[589] = 1;
work.KKT[591] = 1;
work.KKT[593] = 1;
work.KKT[595] = 1;
work.KKT[597] = 1;
work.KKT[599] = 1;
work.KKT[601] = 1;
work.KKT[603] = 1;
work.KKT[605] = 1;
work.KKT[607] = 1;
work.KKT[609] = 1;
work.KKT[611] = 1;
work.KKT[613] = 1;
work.KKT[615] = 1;
work.KKT[617] = 1;
work.KKT[619] = 1;
work.KKT[621] = 1;
work.KKT[623] = 1;
work.KKT[630] = work.block_33[0];
work.KKT[634] = work.block_33[0];
work.KKT[636] = work.block_33[0];
work.KKT[638] = work.block_33[0];
work.KKT[642] = work.block_33[0];
work.KKT[644] = work.block_33[0];
work.KKT[646] = work.block_33[0];
work.KKT[650] = work.block_33[0];
work.KKT[652] = work.block_33[0];
work.KKT[654] = work.block_33[0];
work.KKT[658] = work.block_33[0];
work.KKT[660] = work.block_33[0];
work.KKT[662] = work.block_33[0];
work.KKT[666] = work.block_33[0];
work.KKT[668] = work.block_33[0];
work.KKT[670] = work.block_33[0];
work.KKT[674] = work.block_33[0];
work.KKT[676] = work.block_33[0];
work.KKT[678] = work.block_33[0];
work.KKT[682] = work.block_33[0];
work.KKT[684] = work.block_33[0];
work.KKT[686] = work.block_33[0];
work.KKT[690] = work.block_33[0];
work.KKT[692] = work.block_33[0];
work.KKT[694] = work.block_33[0];
work.KKT[698] = work.block_33[0];
work.KKT[700] = work.block_33[0];
work.KKT[702] = work.block_33[0];
work.KKT[706] = work.block_33[0];
work.KKT[708] = work.block_33[0];
work.KKT[710] = work.block_33[0];
work.KKT[714] = work.block_33[0];
work.KKT[716] = work.block_33[0];
work.KKT[718] = work.block_33[0];
work.KKT[722] = work.block_33[0];
work.KKT[724] = work.block_33[0];
work.KKT[726] = work.block_33[0];
work.KKT[730] = work.block_33[0];
work.KKT[732] = work.block_33[0];
work.KKT[734] = work.block_33[0];
work.KKT[738] = work.block_33[0];
work.KKT[740] = work.block_33[0];
work.KKT[742] = work.block_33[0];
work.KKT[746] = work.block_33[0];
work.KKT[748] = work.block_33[0];
work.KKT[750] = work.block_33[0];
work.KKT[754] = work.block_33[0];
work.KKT[756] = work.block_33[0];
work.KKT[758] = work.block_33[0];
work.KKT[762] = work.block_33[0];
work.KKT[764] = work.block_33[0];
work.KKT[766] = work.block_33[0];
work.KKT[770] = work.block_33[0];
work.KKT[772] = work.block_33[0];
work.KKT[774] = work.block_33[0];
work.KKT[778] = work.block_33[0];
work.KKT[780] = work.block_33[0];
work.KKT[782] = work.block_33[0];
work.KKT[786] = work.block_33[0];
work.KKT[788] = work.block_33[0];
work.KKT[790] = work.block_33[0];
work.KKT[794] = work.block_33[0];
work.KKT[796] = work.block_33[0];
work.KKT[798] = work.block_33[0];
work.KKT[802] = work.block_33[0];
work.KKT[804] = work.block_33[0];
work.KKT[806] = work.block_33[0];
work.KKT[810] = work.block_33[0];
work.KKT[812] = work.block_33[0];
work.KKT[814] = work.block_33[0];
work.KKT[818] = work.block_33[0];
work.KKT[820] = work.block_33[0];
work.KKT[822] = work.block_33[0];
work.KKT[826] = work.block_33[0];
work.KKT[828] = work.block_33[0];
work.KKT[830] = work.block_33[0];
work.KKT[834] = work.block_33[0];
work.KKT[836] = work.block_33[0];
work.KKT[838] = work.block_33[0];
work.KKT[842] = work.block_33[0];
work.KKT[844] = work.block_33[0];
work.KKT[846] = work.block_33[0];
work.KKT[850] = work.block_33[0];
work.KKT[853] = work.block_33[0];
work.KKT[856] = work.block_33[0];
work.KKT[860] = work.block_33[0];
work.KKT[863] = work.block_33[0];
work.KKT[866] = work.block_33[0];
work.KKT[870] = work.block_33[0];
work.KKT[873] = work.block_33[0];
work.KKT[876] = work.block_33[0];
work.KKT[880] = work.block_33[0];
work.KKT[883] = work.block_33[0];
work.KKT[886] = work.block_33[0];
work.KKT[890] = work.block_33[0];
work.KKT[893] = work.block_33[0];
work.KKT[896] = work.block_33[0];
work.KKT[900] = work.block_33[0];
work.KKT[903] = work.block_33[0];
work.KKT[906] = work.block_33[0];
work.KKT[910] = work.block_33[0];
work.KKT[913] = work.block_33[0];
work.KKT[916] = work.block_33[0];
work.KKT[920] = work.block_33[0];
work.KKT[923] = work.block_33[0];
work.KKT[926] = work.block_33[0];
work.KKT[930] = work.block_33[0];
work.KKT[933] = work.block_33[0];
work.KKT[936] = work.block_33[0];
work.KKT[940] = work.block_33[0];
work.KKT[943] = work.block_33[0];
work.KKT[946] = work.block_33[0];
work.KKT[950] = work.block_33[0];
work.KKT[953] = work.block_33[0];
work.KKT[956] = work.block_33[0];
work.KKT[960] = work.block_33[0];
work.KKT[963] = work.block_33[0];
work.KKT[966] = work.block_33[0];
work.KKT[970] = work.block_33[0];
work.KKT[973] = work.block_33[0];
work.KKT[976] = work.block_33[0];
work.KKT[980] = work.block_33[0];
work.KKT[983] = work.block_33[0];
work.KKT[986] = work.block_33[0];
work.KKT[990] = work.block_33[0];
work.KKT[993] = work.block_33[0];
work.KKT[996] = work.block_33[0];
work.KKT[1000] = work.block_33[0];
work.KKT[1003] = work.block_33[0];
work.KKT[1006] = work.block_33[0];
work.KKT[1010] = work.block_33[0];
work.KKT[1013] = work.block_33[0];
work.KKT[1016] = work.block_33[0];
work.KKT[1020] = work.block_33[0];
work.KKT[1023] = work.block_33[0];
work.KKT[1026] = work.block_33[0];
work.KKT[1030] = work.block_33[0];
work.KKT[1033] = work.block_33[0];
work.KKT[1036] = work.block_33[0];
work.KKT[1040] = work.block_33[0];
work.KKT[1043] = work.block_33[0];
work.KKT[1046] = work.block_33[0];
work.KKT[1050] = work.block_33[0];
work.KKT[1053] = work.block_33[0];
work.KKT[1056] = work.block_33[0];
work.KKT[1060] = work.block_33[0];
work.KKT[1063] = work.block_33[0];
work.KKT[1066] = work.block_33[0];
work.KKT[1070] = work.block_33[0];
work.KKT[1073] = work.block_33[0];
work.KKT[1076] = work.block_33[0];
work.KKT[1080] = work.block_33[0];
work.KKT[1083] = work.block_33[0];
work.KKT[1086] = work.block_33[0];
work.KKT[1090] = work.block_33[0];
work.KKT[1093] = work.block_33[0];
work.KKT[1096] = work.block_33[0];
work.KKT[1100] = work.block_33[0];
work.KKT[1102] = work.block_33[0];
work.KKT[1104] = work.block_33[0];
work.KKT[1108] = work.block_33[0];
work.KKT[1110] = work.block_33[0];
work.KKT[1112] = work.block_33[0];
work.KKT[1116] = work.block_33[0];
work.KKT[1118] = work.block_33[0];
work.KKT[1120] = work.block_33[0];
work.KKT[1124] = work.block_33[0];
work.KKT[1126] = work.block_33[0];
work.KKT[1128] = work.block_33[0];
work.KKT[1132] = work.block_33[0];
work.KKT[1134] = work.block_33[0];
work.KKT[1136] = work.block_33[0];
work.KKT[1140] = work.block_33[0];
work.KKT[1142] = work.block_33[0];
work.KKT[1144] = work.block_33[0];
work.KKT[1148] = work.block_33[0];
work.KKT[1150] = work.block_33[0];
work.KKT[1152] = work.block_33[0];
work.KKT[1156] = work.block_33[0];
work.KKT[1158] = work.block_33[0];
work.KKT[1160] = work.block_33[0];
work.KKT[1164] = work.block_33[0];
work.KKT[1166] = work.block_33[0];
work.KKT[1168] = work.block_33[0];
work.KKT[1172] = work.block_33[0];
work.KKT[1174] = work.block_33[0];
work.KKT[1176] = work.block_33[0];
work.KKT[1180] = work.block_33[0];
work.KKT[1182] = work.block_33[0];
work.KKT[1184] = work.block_33[0];
work.KKT[1188] = work.block_33[0];
work.KKT[1190] = work.block_33[0];
work.KKT[1192] = work.block_33[0];
work.KKT[1196] = work.block_33[0];
work.KKT[1198] = work.block_33[0];
work.KKT[1200] = work.block_33[0];
work.KKT[1204] = work.block_33[0];
work.KKT[1206] = work.block_33[0];
work.KKT[1208] = work.block_33[0];
work.KKT[1212] = work.block_33[0];
work.KKT[1214] = work.block_33[0];
work.KKT[1216] = work.block_33[0];
work.KKT[1220] = work.block_33[0];
work.KKT[1222] = work.block_33[0];
work.KKT[1224] = work.block_33[0];
work.KKT[1228] = work.block_33[0];
work.KKT[1230] = work.block_33[0];
work.KKT[1232] = work.block_33[0];
work.KKT[1236] = work.block_33[0];
work.KKT[1238] = work.block_33[0];
work.KKT[1240] = work.block_33[0];
work.KKT[1244] = work.block_33[0];
work.KKT[1246] = work.block_33[0];
work.KKT[1248] = work.block_33[0];
work.KKT[1252] = work.block_33[0];
work.KKT[1254] = work.block_33[0];
work.KKT[1256] = work.block_33[0];
work.KKT[1260] = work.block_33[0];
work.KKT[1262] = work.block_33[0];
work.KKT[1264] = work.block_33[0];
work.KKT[1268] = work.block_33[0];
work.KKT[1270] = work.block_33[0];
work.KKT[1272] = work.block_33[0];
work.KKT[1276] = work.block_33[0];
work.KKT[1278] = work.block_33[0];
work.KKT[1280] = work.block_33[0];
work.KKT[1284] = work.block_33[0];
work.KKT[1286] = work.block_33[0];
work.KKT[1288] = work.block_33[0];
work.KKT[1292] = work.block_33[0];
work.KKT[1294] = work.block_33[0];
work.KKT[1296] = work.block_33[0];
work.KKT[1300] = work.block_33[0];
work.KKT[1302] = work.block_33[0];
work.KKT[1306] = work.block_33[0];
work.KKT[1310] = work.block_33[0];
work.KKT[1312] = work.block_33[0];
work.KKT[1314] = work.block_33[0];
work.KKT[1318] = work.block_33[0];
work.KKT[1320] = work.block_33[0];
work.KKT[1322] = work.block_33[0];
work.KKT[1326] = work.block_33[0];
work.KKT[1328] = work.block_33[0];
work.KKT[1330] = work.block_33[0];
work.KKT[1334] = work.block_33[0];
work.KKT[1336] = work.block_33[0];
work.KKT[1338] = work.block_33[0];
work.KKT[1342] = work.block_33[0];
work.KKT[1344] = work.block_33[0];
work.KKT[1346] = work.block_33[0];
work.KKT[1350] = work.block_33[0];
work.KKT[1352] = work.block_33[0];
work.KKT[1354] = work.block_33[0];
work.KKT[1358] = work.block_33[0];
work.KKT[1360] = work.block_33[0];
work.KKT[1362] = work.block_33[0];
work.KKT[1366] = work.block_33[0];
work.KKT[1368] = work.block_33[0];
work.KKT[1370] = work.block_33[0];
work.KKT[1374] = work.block_33[0];
work.KKT[1376] = work.block_33[0];
work.KKT[1378] = work.block_33[0];
work.KKT[1382] = work.block_33[0];
work.KKT[1384] = work.block_33[0];
work.KKT[1386] = work.block_33[0];
work.KKT[1390] = work.block_33[0];
work.KKT[1392] = work.block_33[0];
work.KKT[1394] = work.block_33[0];
work.KKT[1398] = work.block_33[0];
work.KKT[1400] = work.block_33[0];
work.KKT[1402] = work.block_33[0];
work.KKT[1406] = work.block_33[0];
work.KKT[1408] = work.block_33[0];
work.KKT[1410] = work.block_33[0];
work.KKT[1414] = work.block_33[0];
work.KKT[1416] = work.block_33[0];
work.KKT[1418] = work.block_33[0];
work.KKT[1422] = work.block_33[0];
work.KKT[1424] = work.block_33[0];
work.KKT[1426] = work.block_33[0];
work.KKT[1430] = work.block_33[0];
work.KKT[1432] = work.block_33[0];
work.KKT[1434] = work.block_33[0];
work.KKT[1438] = work.block_33[0];
work.KKT[1440] = work.block_33[0];
work.KKT[1442] = work.block_33[0];
work.KKT[1446] = work.block_33[0];
work.KKT[1448] = work.block_33[0];
work.KKT[1450] = work.block_33[0];
work.KKT[1454] = work.block_33[0];
work.KKT[1456] = work.block_33[0];
work.KKT[1458] = work.block_33[0];
work.KKT[1462] = work.block_33[0];
work.KKT[1464] = work.block_33[0];
work.KKT[1466] = work.block_33[0];
work.KKT[1470] = work.block_33[0];
work.KKT[1472] = work.block_33[0];
work.KKT[1474] = work.block_33[0];
work.KKT[1478] = work.block_33[0];
work.KKT[1480] = work.block_33[0];
work.KKT[1482] = work.block_33[0];
work.KKT[1486] = work.block_33[0];
work.KKT[1488] = work.block_33[0];
work.KKT[1490] = work.block_33[0];
work.KKT[1494] = work.block_33[0];
work.KKT[1496] = work.block_33[0];
work.KKT[1498] = work.block_33[0];
work.KKT[1502] = work.block_33[0];
work.KKT[1504] = work.block_33[0];
work.KKT[1506] = work.block_33[0];
work.KKT[1510] = work.block_33[0];
work.KKT[1512] = work.block_33[0];
work.KKT[631] = 1;
work.KKT[632] = -1;
work.KKT[635] = 1;
work.KKT[633] = -1;
work.KKT[637] = -1;
work.KKT[639] = 1;
work.KKT[640] = -1;
work.KKT[643] = 1;
work.KKT[641] = -1;
work.KKT[645] = -1;
work.KKT[647] = 1;
work.KKT[648] = -1;
work.KKT[651] = 1;
work.KKT[649] = -1;
work.KKT[653] = -1;
work.KKT[655] = 1;
work.KKT[656] = -1;
work.KKT[659] = 1;
work.KKT[657] = -1;
work.KKT[661] = -1;
work.KKT[663] = 1;
work.KKT[664] = -1;
work.KKT[667] = 1;
work.KKT[665] = -1;
work.KKT[669] = -1;
work.KKT[671] = 1;
work.KKT[672] = -1;
work.KKT[675] = 1;
work.KKT[673] = -1;
work.KKT[677] = -1;
work.KKT[679] = 1;
work.KKT[680] = -1;
work.KKT[683] = 1;
work.KKT[681] = -1;
work.KKT[685] = -1;
work.KKT[687] = 1;
work.KKT[688] = -1;
work.KKT[691] = 1;
work.KKT[689] = -1;
work.KKT[693] = -1;
work.KKT[695] = 1;
work.KKT[696] = -1;
work.KKT[699] = 1;
work.KKT[697] = -1;
work.KKT[701] = -1;
work.KKT[703] = 1;
work.KKT[704] = -1;
work.KKT[707] = 1;
work.KKT[705] = -1;
work.KKT[709] = -1;
work.KKT[711] = 1;
work.KKT[712] = -1;
work.KKT[715] = 1;
work.KKT[713] = -1;
work.KKT[717] = -1;
work.KKT[719] = 1;
work.KKT[720] = -1;
work.KKT[723] = 1;
work.KKT[721] = -1;
work.KKT[725] = -1;
work.KKT[727] = 1;
work.KKT[728] = -1;
work.KKT[731] = 1;
work.KKT[729] = -1;
work.KKT[733] = -1;
work.KKT[735] = 1;
work.KKT[736] = -1;
work.KKT[739] = 1;
work.KKT[737] = -1;
work.KKT[741] = -1;
work.KKT[743] = 1;
work.KKT[744] = -1;
work.KKT[747] = 1;
work.KKT[745] = -1;
work.KKT[749] = -1;
work.KKT[751] = 1;
work.KKT[752] = -1;
work.KKT[755] = 1;
work.KKT[753] = -1;
work.KKT[757] = -1;
work.KKT[759] = 1;
work.KKT[760] = -1;
work.KKT[763] = 1;
work.KKT[761] = -1;
work.KKT[765] = -1;
work.KKT[767] = 1;
work.KKT[768] = -1;
work.KKT[771] = 1;
work.KKT[769] = -1;
work.KKT[773] = -1;
work.KKT[775] = 1;
work.KKT[776] = -1;
work.KKT[779] = 1;
work.KKT[777] = -1;
work.KKT[781] = -1;
work.KKT[783] = 1;
work.KKT[784] = -1;
work.KKT[787] = 1;
work.KKT[785] = -1;
work.KKT[789] = -1;
work.KKT[791] = 1;
work.KKT[792] = -1;
work.KKT[795] = 1;
work.KKT[793] = -1;
work.KKT[797] = -1;
work.KKT[799] = 1;
work.KKT[800] = -1;
work.KKT[803] = 1;
work.KKT[801] = -1;
work.KKT[805] = -1;
work.KKT[807] = 1;
work.KKT[808] = -1;
work.KKT[811] = 1;
work.KKT[809] = -1;
work.KKT[813] = -1;
work.KKT[815] = 1;
work.KKT[816] = -1;
work.KKT[819] = 1;
work.KKT[817] = -1;
work.KKT[821] = -1;
work.KKT[823] = 1;
work.KKT[824] = -1;
work.KKT[827] = 1;
work.KKT[825] = -1;
work.KKT[829] = -1;
work.KKT[831] = 1;
work.KKT[832] = -1;
work.KKT[835] = 1;
work.KKT[833] = -1;
work.KKT[837] = -1;
work.KKT[839] = 1;
work.KKT[840] = -1;
work.KKT[843] = 1;
work.KKT[841] = -1;
work.KKT[845] = -1;
work.KKT[847] = 1;
work.KKT[848] = -1;
work.KKT[851] = -1;
work.KKT[852] = 1;
work.KKT[849] = -1;
work.KKT[854] = 1;
work.KKT[855] = -1;
work.KKT[857] = 1;
work.KKT[858] = -1;
work.KKT[861] = -1;
work.KKT[862] = 1;
work.KKT[859] = -1;
work.KKT[864] = 1;
work.KKT[865] = -1;
work.KKT[867] = 1;
work.KKT[868] = -1;
work.KKT[871] = -1;
work.KKT[872] = 1;
work.KKT[869] = -1;
work.KKT[874] = 1;
work.KKT[875] = -1;
work.KKT[877] = 1;
work.KKT[878] = -1;
work.KKT[881] = -1;
work.KKT[882] = 1;
work.KKT[879] = -1;
work.KKT[884] = 1;
work.KKT[885] = -1;
work.KKT[887] = 1;
work.KKT[888] = -1;
work.KKT[891] = -1;
work.KKT[892] = 1;
work.KKT[889] = -1;
work.KKT[894] = 1;
work.KKT[895] = -1;
work.KKT[897] = 1;
work.KKT[898] = -1;
work.KKT[901] = -1;
work.KKT[902] = 1;
work.KKT[899] = -1;
work.KKT[904] = 1;
work.KKT[905] = -1;
work.KKT[907] = 1;
work.KKT[908] = -1;
work.KKT[911] = -1;
work.KKT[912] = 1;
work.KKT[909] = -1;
work.KKT[914] = 1;
work.KKT[915] = -1;
work.KKT[917] = 1;
work.KKT[918] = -1;
work.KKT[921] = -1;
work.KKT[922] = 1;
work.KKT[919] = -1;
work.KKT[924] = 1;
work.KKT[925] = -1;
work.KKT[927] = 1;
work.KKT[928] = -1;
work.KKT[931] = -1;
work.KKT[932] = 1;
work.KKT[929] = -1;
work.KKT[934] = 1;
work.KKT[935] = -1;
work.KKT[937] = 1;
work.KKT[938] = -1;
work.KKT[941] = -1;
work.KKT[942] = 1;
work.KKT[939] = -1;
work.KKT[944] = 1;
work.KKT[945] = -1;
work.KKT[947] = 1;
work.KKT[948] = -1;
work.KKT[951] = -1;
work.KKT[952] = 1;
work.KKT[949] = -1;
work.KKT[954] = 1;
work.KKT[955] = -1;
work.KKT[957] = 1;
work.KKT[958] = -1;
work.KKT[961] = -1;
work.KKT[962] = 1;
work.KKT[959] = -1;
work.KKT[964] = 1;
work.KKT[965] = -1;
work.KKT[967] = 1;
work.KKT[968] = -1;
work.KKT[971] = -1;
work.KKT[972] = 1;
work.KKT[969] = -1;
work.KKT[974] = 1;
work.KKT[975] = -1;
work.KKT[977] = 1;
work.KKT[978] = -1;
work.KKT[981] = -1;
work.KKT[982] = 1;
work.KKT[979] = -1;
work.KKT[984] = 1;
work.KKT[985] = -1;
work.KKT[987] = 1;
work.KKT[988] = -1;
work.KKT[991] = -1;
work.KKT[992] = 1;
work.KKT[989] = -1;
work.KKT[994] = 1;
work.KKT[995] = -1;
work.KKT[997] = 1;
work.KKT[998] = -1;
work.KKT[1001] = -1;
work.KKT[1002] = 1;
work.KKT[999] = -1;
work.KKT[1004] = 1;
work.KKT[1005] = -1;
work.KKT[1007] = 1;
work.KKT[1008] = -1;
work.KKT[1011] = -1;
work.KKT[1012] = 1;
work.KKT[1009] = -1;
work.KKT[1014] = 1;
work.KKT[1015] = -1;
work.KKT[1017] = 1;
work.KKT[1018] = -1;
work.KKT[1021] = -1;
work.KKT[1022] = 1;
work.KKT[1019] = -1;
work.KKT[1024] = 1;
work.KKT[1025] = -1;
work.KKT[1027] = 1;
work.KKT[1028] = -1;
work.KKT[1031] = -1;
work.KKT[1032] = 1;
work.KKT[1029] = -1;
work.KKT[1034] = 1;
work.KKT[1035] = -1;
work.KKT[1037] = 1;
work.KKT[1038] = -1;
work.KKT[1041] = -1;
work.KKT[1042] = 1;
work.KKT[1039] = -1;
work.KKT[1044] = 1;
work.KKT[1045] = -1;
work.KKT[1047] = 1;
work.KKT[1048] = -1;
work.KKT[1051] = -1;
work.KKT[1052] = 1;
work.KKT[1049] = -1;
work.KKT[1054] = 1;
work.KKT[1055] = -1;
work.KKT[1057] = 1;
work.KKT[1058] = -1;
work.KKT[1061] = -1;
work.KKT[1062] = 1;
work.KKT[1059] = -1;
work.KKT[1064] = 1;
work.KKT[1065] = -1;
work.KKT[1067] = 1;
work.KKT[1068] = -1;
work.KKT[1071] = -1;
work.KKT[1072] = 1;
work.KKT[1069] = -1;
work.KKT[1074] = 1;
work.KKT[1075] = -1;
work.KKT[1077] = 1;
work.KKT[1078] = -1;
work.KKT[1082] = -1;
work.KKT[1081] = 1;
work.KKT[1079] = -1;
work.KKT[1085] = 1;
work.KKT[1084] = -1;
work.KKT[1087] = 1;
work.KKT[1088] = -1;
work.KKT[1092] = -1;
work.KKT[1091] = 1;
work.KKT[1089] = -1;
work.KKT[1095] = 1;
work.KKT[1094] = -1;
work.KKT[1097] = 1;
work.KKT[1098] = -1;
work.KKT[1101] = 1;
work.KKT[1099] = -1;
work.KKT[1103] = -1;
work.KKT[1105] = 1;
work.KKT[1106] = -1;
work.KKT[1109] = 1;
work.KKT[1107] = -1;
work.KKT[1111] = -1;
work.KKT[1113] = 1;
work.KKT[1114] = -1;
work.KKT[1117] = 1;
work.KKT[1115] = -1;
work.KKT[1119] = -1;
work.KKT[1121] = 1;
work.KKT[1122] = -1;
work.KKT[1125] = 1;
work.KKT[1123] = -1;
work.KKT[1127] = -1;
work.KKT[1129] = 1;
work.KKT[1130] = -1;
work.KKT[1133] = 1;
work.KKT[1131] = -1;
work.KKT[1135] = -1;
work.KKT[1137] = 1;
work.KKT[1138] = -1;
work.KKT[1141] = 1;
work.KKT[1139] = -1;
work.KKT[1143] = -1;
work.KKT[1145] = 1;
work.KKT[1146] = -1;
work.KKT[1149] = 1;
work.KKT[1147] = -1;
work.KKT[1151] = -1;
work.KKT[1153] = 1;
work.KKT[1154] = -1;
work.KKT[1157] = 1;
work.KKT[1155] = -1;
work.KKT[1159] = -1;
work.KKT[1161] = 1;
work.KKT[1162] = -1;
work.KKT[1165] = 1;
work.KKT[1163] = -1;
work.KKT[1167] = -1;
work.KKT[1169] = 1;
work.KKT[1170] = -1;
work.KKT[1173] = 1;
work.KKT[1171] = -1;
work.KKT[1175] = -1;
work.KKT[1177] = 1;
work.KKT[1178] = -1;
work.KKT[1181] = 1;
work.KKT[1179] = -1;
work.KKT[1183] = -1;
work.KKT[1185] = 1;
work.KKT[1186] = -1;
work.KKT[1189] = 1;
work.KKT[1187] = -1;
work.KKT[1191] = -1;
work.KKT[1193] = 1;
work.KKT[1194] = -1;
work.KKT[1197] = 1;
work.KKT[1195] = -1;
work.KKT[1199] = -1;
work.KKT[1201] = 1;
work.KKT[1202] = -1;
work.KKT[1205] = 1;
work.KKT[1203] = -1;
work.KKT[1207] = -1;
work.KKT[1209] = 1;
work.KKT[1210] = -1;
work.KKT[1213] = 1;
work.KKT[1211] = -1;
work.KKT[1215] = -1;
work.KKT[1217] = 1;
work.KKT[1218] = -1;
work.KKT[1221] = 1;
work.KKT[1219] = -1;
work.KKT[1223] = -1;
work.KKT[1225] = 1;
work.KKT[1226] = -1;
work.KKT[1229] = 1;
work.KKT[1227] = -1;
work.KKT[1231] = -1;
work.KKT[1233] = 1;
work.KKT[1234] = -1;
work.KKT[1237] = 1;
work.KKT[1235] = -1;
work.KKT[1239] = -1;
work.KKT[1241] = 1;
work.KKT[1242] = -1;
work.KKT[1245] = 1;
work.KKT[1243] = -1;
work.KKT[1247] = -1;
work.KKT[1249] = 1;
work.KKT[1250] = -1;
work.KKT[1253] = 1;
work.KKT[1251] = -1;
work.KKT[1255] = -1;
work.KKT[1257] = 1;
work.KKT[1258] = -1;
work.KKT[1261] = 1;
work.KKT[1259] = -1;
work.KKT[1263] = -1;
work.KKT[1265] = 1;
work.KKT[1266] = -1;
work.KKT[1269] = 1;
work.KKT[1267] = -1;
work.KKT[1271] = -1;
work.KKT[1273] = 1;
work.KKT[1274] = -1;
work.KKT[1277] = 1;
work.KKT[1275] = -1;
work.KKT[1279] = -1;
work.KKT[1281] = 1;
work.KKT[1282] = -1;
work.KKT[1285] = 1;
work.KKT[1283] = -1;
work.KKT[1287] = -1;
work.KKT[1289] = 1;
work.KKT[1290] = -1;
work.KKT[1293] = 1;
work.KKT[1291] = -1;
work.KKT[1295] = -1;
work.KKT[1297] = 1;
work.KKT[1298] = -1;
work.KKT[1301] = 1;
work.KKT[1299] = -1;
work.KKT[1303] = -1;
work.KKT[1307] = 1;
work.KKT[1308] = -1;
work.KKT[1311] = 1;
work.KKT[1309] = -1;
work.KKT[1313] = -1;
work.KKT[1315] = 1;
work.KKT[1316] = -1;
work.KKT[1319] = 1;
work.KKT[1317] = -1;
work.KKT[1321] = -1;
work.KKT[1323] = 1;
work.KKT[1324] = -1;
work.KKT[1327] = 1;
work.KKT[1325] = -1;
work.KKT[1329] = -1;
work.KKT[1331] = 1;
work.KKT[1332] = -1;
work.KKT[1335] = 1;
work.KKT[1333] = -1;
work.KKT[1337] = -1;
work.KKT[1339] = 1;
work.KKT[1340] = -1;
work.KKT[1343] = 1;
work.KKT[1341] = -1;
work.KKT[1345] = -1;
work.KKT[1347] = 1;
work.KKT[1348] = -1;
work.KKT[1351] = 1;
work.KKT[1349] = -1;
work.KKT[1353] = -1;
work.KKT[1355] = 1;
work.KKT[1356] = -1;
work.KKT[1359] = 1;
work.KKT[1357] = -1;
work.KKT[1361] = -1;
work.KKT[1363] = 1;
work.KKT[1364] = -1;
work.KKT[1367] = 1;
work.KKT[1365] = -1;
work.KKT[1369] = -1;
work.KKT[1371] = 1;
work.KKT[1372] = -1;
work.KKT[1375] = 1;
work.KKT[1373] = -1;
work.KKT[1377] = -1;
work.KKT[1379] = 1;
work.KKT[1380] = -1;
work.KKT[1383] = 1;
work.KKT[1381] = -1;
work.KKT[1385] = -1;
work.KKT[1387] = 1;
work.KKT[1388] = -1;
work.KKT[1391] = 1;
work.KKT[1389] = -1;
work.KKT[1393] = -1;
work.KKT[1395] = 1;
work.KKT[1396] = -1;
work.KKT[1399] = 1;
work.KKT[1397] = -1;
work.KKT[1401] = -1;
work.KKT[1403] = 1;
work.KKT[1404] = -1;
work.KKT[1407] = 1;
work.KKT[1405] = -1;
work.KKT[1409] = -1;
work.KKT[1411] = 1;
work.KKT[1412] = -1;
work.KKT[1415] = 1;
work.KKT[1413] = -1;
work.KKT[1417] = -1;
work.KKT[1419] = 1;
work.KKT[1420] = -1;
work.KKT[1423] = 1;
work.KKT[1421] = -1;
work.KKT[1425] = -1;
work.KKT[1427] = 1;
work.KKT[1428] = -1;
work.KKT[1431] = 1;
work.KKT[1429] = -1;
work.KKT[1433] = -1;
work.KKT[1435] = 1;
work.KKT[1436] = -1;
work.KKT[1439] = 1;
work.KKT[1437] = -1;
work.KKT[1441] = -1;
work.KKT[1443] = 1;
work.KKT[1444] = -1;
work.KKT[1447] = 1;
work.KKT[1445] = -1;
work.KKT[1449] = -1;
work.KKT[1451] = 1;
work.KKT[1452] = -1;
work.KKT[1455] = 1;
work.KKT[1453] = -1;
work.KKT[1457] = -1;
work.KKT[1459] = 1;
work.KKT[1460] = -1;
work.KKT[1463] = 1;
work.KKT[1461] = -1;
work.KKT[1465] = -1;
work.KKT[1467] = 1;
work.KKT[1468] = -1;
work.KKT[1471] = 1;
work.KKT[1469] = -1;
work.KKT[1473] = -1;
work.KKT[1475] = 1;
work.KKT[1476] = -1;
work.KKT[1479] = 1;
work.KKT[1477] = -1;
work.KKT[1481] = -1;
work.KKT[1483] = 1;
work.KKT[1484] = -1;
work.KKT[1487] = 1;
work.KKT[1485] = -1;
work.KKT[1489] = -1;
work.KKT[1491] = 1;
work.KKT[1492] = -1;
work.KKT[1495] = 1;
work.KKT[1493] = -1;
work.KKT[1497] = -1;
work.KKT[1499] = 1;
work.KKT[1500] = -1;
work.KKT[1503] = 1;
work.KKT[1501] = -1;
work.KKT[1505] = -1;
work.KKT[1507] = 1;
work.KKT[1508] = -1;
work.KKT[1511] = 1;
work.KKT[1509] = -1;
work.KKT[1513] = -1;
work.KKT[1517] = -params.Bf[0];
work.KKT[624] = 1;
work.KKT[625] = 1;
work.KKT[1518] = 1;
work.KKT[1600] = -params.B[0];
work.KKT[627] = -params.A[0];
work.KKT[1527] = -params.A[1];
work.KKT[1601] = -params.A[2];
work.KKT[1519] = -params.A[3];
work.KKT[1599] = -params.A[4];
work.KKT[1520] = 1;
work.KKT[1598] = 1;
work.KKT[1602] = 1;
work.KKT[1605] = -params.B[0];
work.KKT[1529] = -params.A[0];
work.KKT[1619] = -params.A[1];
work.KKT[1604] = -params.A[2];
work.KKT[1603] = -params.A[3];
work.KKT[1622] = -params.A[4];
work.KKT[1531] = 1;
work.KKT[1623] = 1;
work.KKT[1606] = 1;
work.KKT[1630] = -params.B[0];
work.KKT[1532] = -params.A[0];
work.KKT[1624] = -params.A[1];
work.KKT[1629] = -params.A[2];
work.KKT[1628] = -params.A[3];
work.KKT[1625] = -params.A[4];
work.KKT[1534] = 1;
work.KKT[1626] = 1;
work.KKT[1631] = 1;
work.KKT[1639] = -params.B[0];
work.KKT[1535] = -params.A[0];
work.KKT[1633] = -params.A[1];
work.KKT[1638] = -params.A[2];
work.KKT[1637] = -params.A[3];
work.KKT[1634] = -params.A[4];
work.KKT[1537] = 1;
work.KKT[1635] = 1;
work.KKT[1640] = 1;
work.KKT[1648] = -params.B[0];
work.KKT[1538] = -params.A[0];
work.KKT[1642] = -params.A[1];
work.KKT[1647] = -params.A[2];
work.KKT[1646] = -params.A[3];
work.KKT[1643] = -params.A[4];
work.KKT[1540] = 1;
work.KKT[1644] = 1;
work.KKT[1649] = 1;
work.KKT[1657] = -params.B[0];
work.KKT[1541] = -params.A[0];
work.KKT[1651] = -params.A[1];
work.KKT[1656] = -params.A[2];
work.KKT[1655] = -params.A[3];
work.KKT[1652] = -params.A[4];
work.KKT[1543] = 1;
work.KKT[1653] = 1;
work.KKT[1658] = 1;
work.KKT[1666] = -params.B[0];
work.KKT[1544] = -params.A[0];
work.KKT[1660] = -params.A[1];
work.KKT[1665] = -params.A[2];
work.KKT[1664] = -params.A[3];
work.KKT[1661] = -params.A[4];
work.KKT[1546] = 1;
work.KKT[1662] = 1;
work.KKT[1667] = 1;
work.KKT[1675] = -params.B[0];
work.KKT[1547] = -params.A[0];
work.KKT[1669] = -params.A[1];
work.KKT[1674] = -params.A[2];
work.KKT[1673] = -params.A[3];
work.KKT[1670] = -params.A[4];
work.KKT[1549] = 1;
work.KKT[1671] = 1;
work.KKT[1676] = 1;
work.KKT[1684] = -params.B[0];
work.KKT[1550] = -params.A[0];
work.KKT[1678] = -params.A[1];
work.KKT[1683] = -params.A[2];
work.KKT[1682] = -params.A[3];
work.KKT[1679] = -params.A[4];
work.KKT[1552] = 1;
work.KKT[1680] = 1;
work.KKT[1685] = 1;
work.KKT[1693] = -params.B[0];
work.KKT[1553] = -params.A[0];
work.KKT[1687] = -params.A[1];
work.KKT[1692] = -params.A[2];
work.KKT[1691] = -params.A[3];
work.KKT[1688] = -params.A[4];
work.KKT[1555] = 1;
work.KKT[1689] = 1;
work.KKT[1694] = 1;
work.KKT[1702] = -params.B[0];
work.KKT[1556] = -params.A[0];
work.KKT[1696] = -params.A[1];
work.KKT[1701] = -params.A[2];
work.KKT[1700] = -params.A[3];
work.KKT[1697] = -params.A[4];
work.KKT[1558] = 1;
work.KKT[1698] = 1;
work.KKT[1703] = 1;
work.KKT[1711] = -params.B[0];
work.KKT[1559] = -params.A[0];
work.KKT[1705] = -params.A[1];
work.KKT[1710] = -params.A[2];
work.KKT[1709] = -params.A[3];
work.KKT[1706] = -params.A[4];
work.KKT[1561] = 1;
work.KKT[1707] = 1;
work.KKT[1712] = 1;
work.KKT[1720] = -params.B[0];
work.KKT[1562] = -params.A[0];
work.KKT[1714] = -params.A[1];
work.KKT[1719] = -params.A[2];
work.KKT[1718] = -params.A[3];
work.KKT[1715] = -params.A[4];
work.KKT[1564] = 1;
work.KKT[1716] = 1;
work.KKT[1721] = 1;
work.KKT[1729] = -params.B[0];
work.KKT[1565] = -params.A[0];
work.KKT[1723] = -params.A[1];
work.KKT[1728] = -params.A[2];
work.KKT[1727] = -params.A[3];
work.KKT[1724] = -params.A[4];
work.KKT[1567] = 1;
work.KKT[1725] = 1;
work.KKT[1730] = 1;
work.KKT[1738] = -params.B[0];
work.KKT[1568] = -params.A[0];
work.KKT[1732] = -params.A[1];
work.KKT[1737] = -params.A[2];
work.KKT[1736] = -params.A[3];
work.KKT[1733] = -params.A[4];
work.KKT[1570] = 1;
work.KKT[1734] = 1;
work.KKT[1739] = 1;
work.KKT[1747] = -params.B[0];
work.KKT[1571] = -params.A[0];
work.KKT[1741] = -params.A[1];
work.KKT[1746] = -params.A[2];
work.KKT[1745] = -params.A[3];
work.KKT[1742] = -params.A[4];
work.KKT[1573] = 1;
work.KKT[1743] = 1;
work.KKT[1748] = 1;
work.KKT[1756] = -params.B[0];
work.KKT[1574] = -params.A[0];
work.KKT[1750] = -params.A[1];
work.KKT[1755] = -params.A[2];
work.KKT[1754] = -params.A[3];
work.KKT[1751] = -params.A[4];
work.KKT[1576] = 1;
work.KKT[1752] = 1;
work.KKT[1757] = 1;
work.KKT[1765] = -params.B[0];
work.KKT[1577] = -params.A[0];
work.KKT[1759] = -params.A[1];
work.KKT[1764] = -params.A[2];
work.KKT[1763] = -params.A[3];
work.KKT[1760] = -params.A[4];
work.KKT[1579] = 1;
work.KKT[1761] = 1;
work.KKT[1766] = 1;
work.KKT[1774] = -params.B[0];
work.KKT[1580] = -params.A[0];
work.KKT[1768] = -params.A[1];
work.KKT[1773] = -params.A[2];
work.KKT[1772] = -params.A[3];
work.KKT[1769] = -params.A[4];
work.KKT[1582] = 1;
work.KKT[1770] = 1;
work.KKT[1775] = 1;
work.KKT[1783] = -params.B[0];
work.KKT[1583] = -params.A[0];
work.KKT[1777] = -params.A[1];
work.KKT[1782] = -params.A[2];
work.KKT[1781] = -params.A[3];
work.KKT[1778] = -params.A[4];
work.KKT[1585] = 1;
work.KKT[1779] = 1;
work.KKT[1784] = 1;
work.KKT[1792] = -params.B[0];
work.KKT[1586] = -params.A[0];
work.KKT[1786] = -params.A[1];
work.KKT[1791] = -params.A[2];
work.KKT[1790] = -params.A[3];
work.KKT[1787] = -params.A[4];
work.KKT[1588] = 1;
work.KKT[1788] = 1;
work.KKT[1793] = 1;
work.KKT[1801] = -params.B[0];
work.KKT[1589] = -params.A[0];
work.KKT[1795] = -params.A[1];
work.KKT[1800] = -params.A[2];
work.KKT[1799] = -params.A[3];
work.KKT[1796] = -params.A[4];
work.KKT[1591] = 1;
work.KKT[1797] = 1;
work.KKT[1802] = 1;
work.KKT[1612] = -params.B[0];
work.KKT[1592] = -params.A[0];
work.KKT[1807] = -params.A[1];
work.KKT[1613] = -params.A[2];
work.KKT[1806] = -params.A[3];
work.KKT[1808] = -params.A[4];
work.KKT[1595] = 1;
work.KKT[1809] = 1;
work.KKT[1611] = 1;
work.KKT[1607] = -params.B[0];
work.KKT[1594] = -params.A[0];
work.KKT[1616] = -params.A[1];
work.KKT[1609] = -params.A[2];
work.KKT[1617] = -params.A[3];
work.KKT[1615] = -params.A[4];
work.KKT[1597] = 1;
work.KKT[1614] = 1;
work.KKT[1608] = 1;
work.KKT[1516] = -params.B[0];
work.KKT[1521] = -params.A[0];
work.KKT[1524] = -params.A[1];
work.KKT[1525] = -params.A[2];
work.KKT[1522] = -params.A[3];
work.KKT[1523] = -params.A[4];
work.KKT[629] = 1;
work.KKT[1305] = 1;
work.KKT[1515] = 1;
}
|
larics/uav_ros_control
|
src/control/cvxgen/testsolver.c
|
/* Produced by CVXGEN, 2021-03-12 04:35:32 -0500. */
/* CVXGEN is Copyright (C) 2006-2017 <NAME>, <EMAIL>. */
/* The code in this file is Copyright (C) 2006-2017 <NAME>. */
/* CVXGEN, or solvers produced by CVXGEN, cannot be used for commercial */
/* applications without prior written permission from <NAME>. */
/* Filename: testsolver.c. */
/* Description: Basic test harness for solver.c. */
#include "solver.h"
Vars vars;
Params params;
Workspace work;
Settings settings;
#define NUMTESTS 0
int main(int argc, char **argv) {
int num_iters;
#if (NUMTESTS > 0)
int i;
double time;
double time_per;
#endif
set_defaults();
setup_indexing();
load_default_data();
/* Solve problem instance for the record. */
settings.verbose = 1;
num_iters = solve();
#ifndef ZERO_LIBRARY_MODE
#if (NUMTESTS > 0)
/* Now solve multiple problem instances for timing purposes. */
settings.verbose = 0;
tic();
for (i = 0; i < NUMTESTS; i++) {
solve();
}
time = tocq();
printf("Timed %d solves over %.3f seconds.\n", NUMTESTS, time);
time_per = time / NUMTESTS;
if (time_per > 1) {
printf("Actual time taken per solve: %.3g s.\n", time_per);
} else if (time_per > 1e-3) {
printf("Actual time taken per solve: %.3g ms.\n", 1e3*time_per);
} else {
printf("Actual time taken per solve: %.3g us.\n", 1e6*time_per);
}
#endif
#endif
return 0;
}
void load_default_data(void) {
params.x_ss_1[0] = 0.20319161029830202;
params.x_ss_1[1] = 0.8325912904724193;
params.x_ss_1[2] = -0.8363810443482227;
params.Q[0] = 1.510827605197663;
params.Q[1] = 1.8929469543476547;
params.Q[2] = 1.896293088933438;
params.x_ss_2[0] = -1.497658758144655;
params.x_ss_2[1] = -1.171028487447253;
params.x_ss_2[2] = -1.7941311867966805;
params.x_ss_3[0] = -0.23676062539745413;
params.x_ss_3[1] = -1.8804951564857322;
params.x_ss_3[2] = -0.17266710242115568;
params.x_ss_4[0] = 0.596576190459043;
params.x_ss_4[1] = -0.8860508694080989;
params.x_ss_4[2] = 0.7050196079205251;
params.x_ss_5[0] = 0.3634512696654033;
params.x_ss_5[1] = -1.9040724704913385;
params.x_ss_5[2] = 0.23541635196352795;
params.x_ss_6[0] = -0.9629902123701384;
params.x_ss_6[1] = -0.3395952119597214;
params.x_ss_6[2] = -0.865899672914725;
params.x_ss_7[0] = 0.7725516732519853;
params.x_ss_7[1] = -0.23818512931704205;
params.x_ss_7[2] = -1.372529046100147;
params.x_ss_8[0] = 0.17859607212737894;
params.x_ss_8[1] = 1.1212590580454682;
params.x_ss_8[2] = -0.774545870495281;
params.x_ss_9[0] = -1.1121684642712744;
params.x_ss_9[1] = -0.44811496977740495;
params.x_ss_9[2] = 1.7455345994417217;
params.x_ss_10[0] = 1.9039816898917352;
params.x_ss_10[1] = 0.6895347036512547;
params.x_ss_10[2] = 1.6113364341535923;
params.x_ss_11[0] = 1.383003485172717;
params.x_ss_11[1] = -0.48802383468444344;
params.x_ss_11[2] = -1.631131964513103;
params.x_ss_12[0] = 0.6136436100941447;
params.x_ss_12[1] = 0.2313630495538037;
params.x_ss_12[2] = -0.5537409477496875;
params.x_ss_13[0] = -1.0997819806406723;
params.x_ss_13[1] = -0.3739203344950055;
params.x_ss_13[2] = -0.12423900520332376;
params.x_ss_14[0] = -0.923057686995755;
params.x_ss_14[1] = -0.8328289030982696;
params.x_ss_14[2] = -0.16925440270808823;
params.x_ss_15[0] = 1.442135651787706;
params.x_ss_15[1] = 0.34501161787128565;
params.x_ss_15[2] = -0.8660485502711608;
params.x_ss_16[0] = -0.8880899735055947;
params.x_ss_16[1] = -0.1815116979122129;
params.x_ss_16[2] = -1.17835862158005;
params.x_ss_17[0] = -1.1944851558277074;
params.x_ss_17[1] = 0.05614023926976763;
params.x_ss_17[2] = -1.6510825248767813;
params.x_ss_18[0] = -0.06565787059365391;
params.x_ss_18[1] = -0.5512951504486665;
params.x_ss_18[2] = 0.8307464872626844;
params.x_ss_19[0] = 0.9869848924080182;
params.x_ss_19[1] = 0.7643716874230573;
params.x_ss_19[2] = 0.7567216550196565;
params.x_ss_20[0] = -0.5055995034042868;
params.x_ss_20[1] = 0.6725392189410702;
params.x_ss_20[2] = -0.6406053441727284;
params.x_ss_21[0] = 0.29117547947550015;
params.x_ss_21[1] = -0.6967713677405021;
params.x_ss_21[2] = -0.21941980294587182;
params.x_ss_22[0] = -1.753884276680243;
params.x_ss_22[1] = -1.0292983112626475;
params.x_ss_22[2] = 1.8864104246942706;
params.x_ss_23[0] = -1.077663182579704;
params.x_ss_23[1] = 0.7659100437893209;
params.x_ss_23[2] = 0.6019074328549583;
params.x_ss_24[0] = 0.8957565577499285;
params.x_ss_24[1] = -0.09964555746227477;
params.x_ss_24[2] = 0.38665509840745127;
params.x_ss_25[0] = -1.7321223042686946;
params.x_ss_25[1] = -1.7097514487110663;
params.x_ss_25[2] = -1.2040958948116867;
params.x_ss_26[0] = -1.3925560119658358;
params.x_ss_26[1] = -1.5995826216742213;
params.x_ss_26[2] = -1.4828245415645833;
params.Q_last[0] = 1.5532777318076536;
params.Q_last[1] = 1.1878148249238782;
params.Q_last[2] = 1.9521012430312084;
params.Af[0] = 0.7264471152297065;
params.Af[1] = 0.16407869343908477;
params.Af[2] = 0.8287224032315907;
params.Af[3] = -0.9444533161899464;
params.Af[4] = 1.7069027370149112;
params.x_0[0] = 1.3567722311998827;
params.x_0[1] = 0.9052779937121489;
params.x_0[2] = -0.07904017565835986;
params.Bf[0] = 1.3684127435065871;
params.A[0] = 0.979009293697437;
params.A[1] = 0.6413036255984501;
params.A[2] = 1.6559010680237511;
params.A[3] = 0.5346622551502991;
params.A[4] = -0.5362376605895625;
params.B[0] = 0.2113782926017822;
params.u_max[0] = -1.2144776931994525;
params.u_last[0] = -1.2317108144255875;
params.du_max_f[0] = 0.9026784957312834;
params.du_max[0] = 1.1397468137245244;
params.x_max_2[0] = 1.8883934547350631;
params.x_max_3[0] = 1.4038856681660068;
}
|
larics/uav_ros_control
|
src/control/cvxgen/matrix_support.c
|
<reponame>larics/uav_ros_control
/* Produced by CVXGEN, 2021-03-12 04:35:30 -0500. */
/* CVXGEN is Copyright (C) 2006-2017 <NAME>, <EMAIL>. */
/* The code in this file is Copyright (C) 2006-2017 <NAME>. */
/* CVXGEN, or solvers produced by CVXGEN, cannot be used for commercial */
/* applications without prior written permission from <NAME>. */
/* Filename: matrix_support.c. */
/* Description: Support functions for matrix multiplication and vector filling. */
#include "solver.h"
void multbymA(double *lhs, double *rhs) {
lhs[0] = -rhs[130]*(1);
lhs[1] = -rhs[131]*(1);
lhs[2] = -rhs[104]*(-params.Bf[0])-rhs[132]*(1);
lhs[3] = -rhs[130]*(-params.A[0])-rhs[131]*(-params.A[3])-rhs[133]*(1);
lhs[4] = -rhs[131]*(-params.A[1])-rhs[132]*(-params.A[4])-rhs[134]*(1);
lhs[5] = -rhs[105]*(-params.B[0])-rhs[132]*(-params.A[2])-rhs[135]*(1);
lhs[6] = -rhs[133]*(-params.A[0])-rhs[134]*(-params.A[3])-rhs[136]*(1);
lhs[7] = -rhs[134]*(-params.A[1])-rhs[135]*(-params.A[4])-rhs[137]*(1);
lhs[8] = -rhs[106]*(-params.B[0])-rhs[135]*(-params.A[2])-rhs[138]*(1);
lhs[9] = -rhs[136]*(-params.A[0])-rhs[137]*(-params.A[3])-rhs[139]*(1);
lhs[10] = -rhs[137]*(-params.A[1])-rhs[138]*(-params.A[4])-rhs[140]*(1);
lhs[11] = -rhs[107]*(-params.B[0])-rhs[138]*(-params.A[2])-rhs[141]*(1);
lhs[12] = -rhs[139]*(-params.A[0])-rhs[140]*(-params.A[3])-rhs[142]*(1);
lhs[13] = -rhs[140]*(-params.A[1])-rhs[141]*(-params.A[4])-rhs[143]*(1);
lhs[14] = -rhs[108]*(-params.B[0])-rhs[141]*(-params.A[2])-rhs[144]*(1);
lhs[15] = -rhs[142]*(-params.A[0])-rhs[143]*(-params.A[3])-rhs[145]*(1);
lhs[16] = -rhs[143]*(-params.A[1])-rhs[144]*(-params.A[4])-rhs[146]*(1);
lhs[17] = -rhs[109]*(-params.B[0])-rhs[144]*(-params.A[2])-rhs[147]*(1);
lhs[18] = -rhs[145]*(-params.A[0])-rhs[146]*(-params.A[3])-rhs[148]*(1);
lhs[19] = -rhs[146]*(-params.A[1])-rhs[147]*(-params.A[4])-rhs[149]*(1);
lhs[20] = -rhs[110]*(-params.B[0])-rhs[147]*(-params.A[2])-rhs[150]*(1);
lhs[21] = -rhs[148]*(-params.A[0])-rhs[149]*(-params.A[3])-rhs[151]*(1);
lhs[22] = -rhs[149]*(-params.A[1])-rhs[150]*(-params.A[4])-rhs[152]*(1);
lhs[23] = -rhs[111]*(-params.B[0])-rhs[150]*(-params.A[2])-rhs[153]*(1);
lhs[24] = -rhs[151]*(-params.A[0])-rhs[152]*(-params.A[3])-rhs[154]*(1);
lhs[25] = -rhs[152]*(-params.A[1])-rhs[153]*(-params.A[4])-rhs[155]*(1);
lhs[26] = -rhs[112]*(-params.B[0])-rhs[153]*(-params.A[2])-rhs[156]*(1);
lhs[27] = -rhs[154]*(-params.A[0])-rhs[155]*(-params.A[3])-rhs[157]*(1);
lhs[28] = -rhs[155]*(-params.A[1])-rhs[156]*(-params.A[4])-rhs[158]*(1);
lhs[29] = -rhs[113]*(-params.B[0])-rhs[156]*(-params.A[2])-rhs[159]*(1);
lhs[30] = -rhs[157]*(-params.A[0])-rhs[158]*(-params.A[3])-rhs[160]*(1);
lhs[31] = -rhs[158]*(-params.A[1])-rhs[159]*(-params.A[4])-rhs[161]*(1);
lhs[32] = -rhs[114]*(-params.B[0])-rhs[159]*(-params.A[2])-rhs[162]*(1);
lhs[33] = -rhs[160]*(-params.A[0])-rhs[161]*(-params.A[3])-rhs[163]*(1);
lhs[34] = -rhs[161]*(-params.A[1])-rhs[162]*(-params.A[4])-rhs[164]*(1);
lhs[35] = -rhs[115]*(-params.B[0])-rhs[162]*(-params.A[2])-rhs[165]*(1);
lhs[36] = -rhs[163]*(-params.A[0])-rhs[164]*(-params.A[3])-rhs[166]*(1);
lhs[37] = -rhs[164]*(-params.A[1])-rhs[165]*(-params.A[4])-rhs[167]*(1);
lhs[38] = -rhs[116]*(-params.B[0])-rhs[165]*(-params.A[2])-rhs[168]*(1);
lhs[39] = -rhs[166]*(-params.A[0])-rhs[167]*(-params.A[3])-rhs[169]*(1);
lhs[40] = -rhs[167]*(-params.A[1])-rhs[168]*(-params.A[4])-rhs[170]*(1);
lhs[41] = -rhs[117]*(-params.B[0])-rhs[168]*(-params.A[2])-rhs[171]*(1);
lhs[42] = -rhs[169]*(-params.A[0])-rhs[170]*(-params.A[3])-rhs[172]*(1);
lhs[43] = -rhs[170]*(-params.A[1])-rhs[171]*(-params.A[4])-rhs[173]*(1);
lhs[44] = -rhs[118]*(-params.B[0])-rhs[171]*(-params.A[2])-rhs[174]*(1);
lhs[45] = -rhs[172]*(-params.A[0])-rhs[173]*(-params.A[3])-rhs[175]*(1);
lhs[46] = -rhs[173]*(-params.A[1])-rhs[174]*(-params.A[4])-rhs[176]*(1);
lhs[47] = -rhs[119]*(-params.B[0])-rhs[174]*(-params.A[2])-rhs[177]*(1);
lhs[48] = -rhs[175]*(-params.A[0])-rhs[176]*(-params.A[3])-rhs[178]*(1);
lhs[49] = -rhs[176]*(-params.A[1])-rhs[177]*(-params.A[4])-rhs[179]*(1);
lhs[50] = -rhs[120]*(-params.B[0])-rhs[177]*(-params.A[2])-rhs[180]*(1);
lhs[51] = -rhs[178]*(-params.A[0])-rhs[179]*(-params.A[3])-rhs[181]*(1);
lhs[52] = -rhs[179]*(-params.A[1])-rhs[180]*(-params.A[4])-rhs[182]*(1);
lhs[53] = -rhs[121]*(-params.B[0])-rhs[180]*(-params.A[2])-rhs[183]*(1);
lhs[54] = -rhs[181]*(-params.A[0])-rhs[182]*(-params.A[3])-rhs[184]*(1);
lhs[55] = -rhs[182]*(-params.A[1])-rhs[183]*(-params.A[4])-rhs[185]*(1);
lhs[56] = -rhs[122]*(-params.B[0])-rhs[183]*(-params.A[2])-rhs[186]*(1);
lhs[57] = -rhs[184]*(-params.A[0])-rhs[185]*(-params.A[3])-rhs[187]*(1);
lhs[58] = -rhs[185]*(-params.A[1])-rhs[186]*(-params.A[4])-rhs[188]*(1);
lhs[59] = -rhs[123]*(-params.B[0])-rhs[186]*(-params.A[2])-rhs[189]*(1);
lhs[60] = -rhs[187]*(-params.A[0])-rhs[188]*(-params.A[3])-rhs[190]*(1);
lhs[61] = -rhs[188]*(-params.A[1])-rhs[189]*(-params.A[4])-rhs[191]*(1);
lhs[62] = -rhs[124]*(-params.B[0])-rhs[189]*(-params.A[2])-rhs[192]*(1);
lhs[63] = -rhs[190]*(-params.A[0])-rhs[191]*(-params.A[3])-rhs[193]*(1);
lhs[64] = -rhs[191]*(-params.A[1])-rhs[192]*(-params.A[4])-rhs[194]*(1);
lhs[65] = -rhs[125]*(-params.B[0])-rhs[192]*(-params.A[2])-rhs[195]*(1);
lhs[66] = -rhs[193]*(-params.A[0])-rhs[194]*(-params.A[3])-rhs[196]*(1);
lhs[67] = -rhs[194]*(-params.A[1])-rhs[195]*(-params.A[4])-rhs[197]*(1);
lhs[68] = -rhs[126]*(-params.B[0])-rhs[195]*(-params.A[2])-rhs[198]*(1);
lhs[69] = -rhs[196]*(-params.A[0])-rhs[197]*(-params.A[3])-rhs[199]*(1);
lhs[70] = -rhs[197]*(-params.A[1])-rhs[198]*(-params.A[4])-rhs[200]*(1);
lhs[71] = -rhs[127]*(-params.B[0])-rhs[198]*(-params.A[2])-rhs[201]*(1);
lhs[72] = -rhs[199]*(-params.A[0])-rhs[200]*(-params.A[3])-rhs[202]*(1);
lhs[73] = -rhs[200]*(-params.A[1])-rhs[201]*(-params.A[4])-rhs[203]*(1);
lhs[74] = -rhs[128]*(-params.B[0])-rhs[201]*(-params.A[2])-rhs[204]*(1);
lhs[75] = -rhs[202]*(-params.A[0])-rhs[203]*(-params.A[3])-rhs[205]*(1);
lhs[76] = -rhs[203]*(-params.A[1])-rhs[204]*(-params.A[4])-rhs[206]*(1);
lhs[77] = -rhs[129]*(-params.B[0])-rhs[204]*(-params.A[2])-rhs[207]*(1);
}
void multbymAT(double *lhs, double *rhs) {
lhs[0] = 0;
lhs[1] = 0;
lhs[2] = 0;
lhs[3] = 0;
lhs[4] = 0;
lhs[5] = 0;
lhs[6] = 0;
lhs[7] = 0;
lhs[8] = 0;
lhs[9] = 0;
lhs[10] = 0;
lhs[11] = 0;
lhs[12] = 0;
lhs[13] = 0;
lhs[14] = 0;
lhs[15] = 0;
lhs[16] = 0;
lhs[17] = 0;
lhs[18] = 0;
lhs[19] = 0;
lhs[20] = 0;
lhs[21] = 0;
lhs[22] = 0;
lhs[23] = 0;
lhs[24] = 0;
lhs[25] = 0;
lhs[26] = 0;
lhs[27] = 0;
lhs[28] = 0;
lhs[29] = 0;
lhs[30] = 0;
lhs[31] = 0;
lhs[32] = 0;
lhs[33] = 0;
lhs[34] = 0;
lhs[35] = 0;
lhs[36] = 0;
lhs[37] = 0;
lhs[38] = 0;
lhs[39] = 0;
lhs[40] = 0;
lhs[41] = 0;
lhs[42] = 0;
lhs[43] = 0;
lhs[44] = 0;
lhs[45] = 0;
lhs[46] = 0;
lhs[47] = 0;
lhs[48] = 0;
lhs[49] = 0;
lhs[50] = 0;
lhs[51] = 0;
lhs[52] = 0;
lhs[53] = 0;
lhs[54] = 0;
lhs[55] = 0;
lhs[56] = 0;
lhs[57] = 0;
lhs[58] = 0;
lhs[59] = 0;
lhs[60] = 0;
lhs[61] = 0;
lhs[62] = 0;
lhs[63] = 0;
lhs[64] = 0;
lhs[65] = 0;
lhs[66] = 0;
lhs[67] = 0;
lhs[68] = 0;
lhs[69] = 0;
lhs[70] = 0;
lhs[71] = 0;
lhs[72] = 0;
lhs[73] = 0;
lhs[74] = 0;
lhs[75] = 0;
lhs[76] = 0;
lhs[77] = 0;
lhs[78] = 0;
lhs[79] = 0;
lhs[80] = 0;
lhs[81] = 0;
lhs[82] = 0;
lhs[83] = 0;
lhs[84] = 0;
lhs[85] = 0;
lhs[86] = 0;
lhs[87] = 0;
lhs[88] = 0;
lhs[89] = 0;
lhs[90] = 0;
lhs[91] = 0;
lhs[92] = 0;
lhs[93] = 0;
lhs[94] = 0;
lhs[95] = 0;
lhs[96] = 0;
lhs[97] = 0;
lhs[98] = 0;
lhs[99] = 0;
lhs[100] = 0;
lhs[101] = 0;
lhs[102] = 0;
lhs[103] = 0;
lhs[104] = -rhs[2]*(-params.Bf[0]);
lhs[105] = -rhs[5]*(-params.B[0]);
lhs[106] = -rhs[8]*(-params.B[0]);
lhs[107] = -rhs[11]*(-params.B[0]);
lhs[108] = -rhs[14]*(-params.B[0]);
lhs[109] = -rhs[17]*(-params.B[0]);
lhs[110] = -rhs[20]*(-params.B[0]);
lhs[111] = -rhs[23]*(-params.B[0]);
lhs[112] = -rhs[26]*(-params.B[0]);
lhs[113] = -rhs[29]*(-params.B[0]);
lhs[114] = -rhs[32]*(-params.B[0]);
lhs[115] = -rhs[35]*(-params.B[0]);
lhs[116] = -rhs[38]*(-params.B[0]);
lhs[117] = -rhs[41]*(-params.B[0]);
lhs[118] = -rhs[44]*(-params.B[0]);
lhs[119] = -rhs[47]*(-params.B[0]);
lhs[120] = -rhs[50]*(-params.B[0]);
lhs[121] = -rhs[53]*(-params.B[0]);
lhs[122] = -rhs[56]*(-params.B[0]);
lhs[123] = -rhs[59]*(-params.B[0]);
lhs[124] = -rhs[62]*(-params.B[0]);
lhs[125] = -rhs[65]*(-params.B[0]);
lhs[126] = -rhs[68]*(-params.B[0]);
lhs[127] = -rhs[71]*(-params.B[0]);
lhs[128] = -rhs[74]*(-params.B[0]);
lhs[129] = -rhs[77]*(-params.B[0]);
lhs[130] = -rhs[0]*(1)-rhs[3]*(-params.A[0]);
lhs[131] = -rhs[1]*(1)-rhs[4]*(-params.A[1])-rhs[3]*(-params.A[3]);
lhs[132] = -rhs[2]*(1)-rhs[5]*(-params.A[2])-rhs[4]*(-params.A[4]);
lhs[133] = -rhs[3]*(1)-rhs[6]*(-params.A[0]);
lhs[134] = -rhs[4]*(1)-rhs[7]*(-params.A[1])-rhs[6]*(-params.A[3]);
lhs[135] = -rhs[5]*(1)-rhs[8]*(-params.A[2])-rhs[7]*(-params.A[4]);
lhs[136] = -rhs[6]*(1)-rhs[9]*(-params.A[0]);
lhs[137] = -rhs[7]*(1)-rhs[10]*(-params.A[1])-rhs[9]*(-params.A[3]);
lhs[138] = -rhs[8]*(1)-rhs[11]*(-params.A[2])-rhs[10]*(-params.A[4]);
lhs[139] = -rhs[9]*(1)-rhs[12]*(-params.A[0]);
lhs[140] = -rhs[10]*(1)-rhs[13]*(-params.A[1])-rhs[12]*(-params.A[3]);
lhs[141] = -rhs[11]*(1)-rhs[14]*(-params.A[2])-rhs[13]*(-params.A[4]);
lhs[142] = -rhs[12]*(1)-rhs[15]*(-params.A[0]);
lhs[143] = -rhs[13]*(1)-rhs[16]*(-params.A[1])-rhs[15]*(-params.A[3]);
lhs[144] = -rhs[14]*(1)-rhs[17]*(-params.A[2])-rhs[16]*(-params.A[4]);
lhs[145] = -rhs[15]*(1)-rhs[18]*(-params.A[0]);
lhs[146] = -rhs[16]*(1)-rhs[19]*(-params.A[1])-rhs[18]*(-params.A[3]);
lhs[147] = -rhs[17]*(1)-rhs[20]*(-params.A[2])-rhs[19]*(-params.A[4]);
lhs[148] = -rhs[18]*(1)-rhs[21]*(-params.A[0]);
lhs[149] = -rhs[19]*(1)-rhs[22]*(-params.A[1])-rhs[21]*(-params.A[3]);
lhs[150] = -rhs[20]*(1)-rhs[23]*(-params.A[2])-rhs[22]*(-params.A[4]);
lhs[151] = -rhs[21]*(1)-rhs[24]*(-params.A[0]);
lhs[152] = -rhs[22]*(1)-rhs[25]*(-params.A[1])-rhs[24]*(-params.A[3]);
lhs[153] = -rhs[23]*(1)-rhs[26]*(-params.A[2])-rhs[25]*(-params.A[4]);
lhs[154] = -rhs[24]*(1)-rhs[27]*(-params.A[0]);
lhs[155] = -rhs[25]*(1)-rhs[28]*(-params.A[1])-rhs[27]*(-params.A[3]);
lhs[156] = -rhs[26]*(1)-rhs[29]*(-params.A[2])-rhs[28]*(-params.A[4]);
lhs[157] = -rhs[27]*(1)-rhs[30]*(-params.A[0]);
lhs[158] = -rhs[28]*(1)-rhs[31]*(-params.A[1])-rhs[30]*(-params.A[3]);
lhs[159] = -rhs[29]*(1)-rhs[32]*(-params.A[2])-rhs[31]*(-params.A[4]);
lhs[160] = -rhs[30]*(1)-rhs[33]*(-params.A[0]);
lhs[161] = -rhs[31]*(1)-rhs[34]*(-params.A[1])-rhs[33]*(-params.A[3]);
lhs[162] = -rhs[32]*(1)-rhs[35]*(-params.A[2])-rhs[34]*(-params.A[4]);
lhs[163] = -rhs[33]*(1)-rhs[36]*(-params.A[0]);
lhs[164] = -rhs[34]*(1)-rhs[37]*(-params.A[1])-rhs[36]*(-params.A[3]);
lhs[165] = -rhs[35]*(1)-rhs[38]*(-params.A[2])-rhs[37]*(-params.A[4]);
lhs[166] = -rhs[36]*(1)-rhs[39]*(-params.A[0]);
lhs[167] = -rhs[37]*(1)-rhs[40]*(-params.A[1])-rhs[39]*(-params.A[3]);
lhs[168] = -rhs[38]*(1)-rhs[41]*(-params.A[2])-rhs[40]*(-params.A[4]);
lhs[169] = -rhs[39]*(1)-rhs[42]*(-params.A[0]);
lhs[170] = -rhs[40]*(1)-rhs[43]*(-params.A[1])-rhs[42]*(-params.A[3]);
lhs[171] = -rhs[41]*(1)-rhs[44]*(-params.A[2])-rhs[43]*(-params.A[4]);
lhs[172] = -rhs[42]*(1)-rhs[45]*(-params.A[0]);
lhs[173] = -rhs[43]*(1)-rhs[46]*(-params.A[1])-rhs[45]*(-params.A[3]);
lhs[174] = -rhs[44]*(1)-rhs[47]*(-params.A[2])-rhs[46]*(-params.A[4]);
lhs[175] = -rhs[45]*(1)-rhs[48]*(-params.A[0]);
lhs[176] = -rhs[46]*(1)-rhs[49]*(-params.A[1])-rhs[48]*(-params.A[3]);
lhs[177] = -rhs[47]*(1)-rhs[50]*(-params.A[2])-rhs[49]*(-params.A[4]);
lhs[178] = -rhs[48]*(1)-rhs[51]*(-params.A[0]);
lhs[179] = -rhs[49]*(1)-rhs[52]*(-params.A[1])-rhs[51]*(-params.A[3]);
lhs[180] = -rhs[50]*(1)-rhs[53]*(-params.A[2])-rhs[52]*(-params.A[4]);
lhs[181] = -rhs[51]*(1)-rhs[54]*(-params.A[0]);
lhs[182] = -rhs[52]*(1)-rhs[55]*(-params.A[1])-rhs[54]*(-params.A[3]);
lhs[183] = -rhs[53]*(1)-rhs[56]*(-params.A[2])-rhs[55]*(-params.A[4]);
lhs[184] = -rhs[54]*(1)-rhs[57]*(-params.A[0]);
lhs[185] = -rhs[55]*(1)-rhs[58]*(-params.A[1])-rhs[57]*(-params.A[3]);
lhs[186] = -rhs[56]*(1)-rhs[59]*(-params.A[2])-rhs[58]*(-params.A[4]);
lhs[187] = -rhs[57]*(1)-rhs[60]*(-params.A[0]);
lhs[188] = -rhs[58]*(1)-rhs[61]*(-params.A[1])-rhs[60]*(-params.A[3]);
lhs[189] = -rhs[59]*(1)-rhs[62]*(-params.A[2])-rhs[61]*(-params.A[4]);
lhs[190] = -rhs[60]*(1)-rhs[63]*(-params.A[0]);
lhs[191] = -rhs[61]*(1)-rhs[64]*(-params.A[1])-rhs[63]*(-params.A[3]);
lhs[192] = -rhs[62]*(1)-rhs[65]*(-params.A[2])-rhs[64]*(-params.A[4]);
lhs[193] = -rhs[63]*(1)-rhs[66]*(-params.A[0]);
lhs[194] = -rhs[64]*(1)-rhs[67]*(-params.A[1])-rhs[66]*(-params.A[3]);
lhs[195] = -rhs[65]*(1)-rhs[68]*(-params.A[2])-rhs[67]*(-params.A[4]);
lhs[196] = -rhs[66]*(1)-rhs[69]*(-params.A[0]);
lhs[197] = -rhs[67]*(1)-rhs[70]*(-params.A[1])-rhs[69]*(-params.A[3]);
lhs[198] = -rhs[68]*(1)-rhs[71]*(-params.A[2])-rhs[70]*(-params.A[4]);
lhs[199] = -rhs[69]*(1)-rhs[72]*(-params.A[0]);
lhs[200] = -rhs[70]*(1)-rhs[73]*(-params.A[1])-rhs[72]*(-params.A[3]);
lhs[201] = -rhs[71]*(1)-rhs[74]*(-params.A[2])-rhs[73]*(-params.A[4]);
lhs[202] = -rhs[72]*(1)-rhs[75]*(-params.A[0]);
lhs[203] = -rhs[73]*(1)-rhs[76]*(-params.A[1])-rhs[75]*(-params.A[3]);
lhs[204] = -rhs[74]*(1)-rhs[77]*(-params.A[2])-rhs[76]*(-params.A[4]);
lhs[205] = -rhs[75]*(1);
lhs[206] = -rhs[76]*(1);
lhs[207] = -rhs[77]*(1);
}
void multbymG(double *lhs, double *rhs) {
lhs[0] = -rhs[0]*(1);
lhs[1] = -rhs[0]*(-1)-rhs[104]*(1);
lhs[2] = -rhs[0]*(-1)-rhs[104]*(-1);
lhs[3] = -rhs[1]*(1);
lhs[4] = -rhs[1]*(-1)-rhs[105]*(1);
lhs[5] = -rhs[1]*(-1)-rhs[105]*(-1);
lhs[6] = -rhs[2]*(1);
lhs[7] = -rhs[2]*(-1)-rhs[106]*(1);
lhs[8] = -rhs[2]*(-1)-rhs[106]*(-1);
lhs[9] = -rhs[3]*(1);
lhs[10] = -rhs[3]*(-1)-rhs[107]*(1);
lhs[11] = -rhs[3]*(-1)-rhs[107]*(-1);
lhs[12] = -rhs[4]*(1);
lhs[13] = -rhs[4]*(-1)-rhs[108]*(1);
lhs[14] = -rhs[4]*(-1)-rhs[108]*(-1);
lhs[15] = -rhs[5]*(1);
lhs[16] = -rhs[5]*(-1)-rhs[109]*(1);
lhs[17] = -rhs[5]*(-1)-rhs[109]*(-1);
lhs[18] = -rhs[6]*(1);
lhs[19] = -rhs[6]*(-1)-rhs[110]*(1);
lhs[20] = -rhs[6]*(-1)-rhs[110]*(-1);
lhs[21] = -rhs[7]*(1);
lhs[22] = -rhs[7]*(-1)-rhs[111]*(1);
lhs[23] = -rhs[7]*(-1)-rhs[111]*(-1);
lhs[24] = -rhs[8]*(1);
lhs[25] = -rhs[8]*(-1)-rhs[112]*(1);
lhs[26] = -rhs[8]*(-1)-rhs[112]*(-1);
lhs[27] = -rhs[9]*(1);
lhs[28] = -rhs[9]*(-1)-rhs[113]*(1);
lhs[29] = -rhs[9]*(-1)-rhs[113]*(-1);
lhs[30] = -rhs[10]*(1);
lhs[31] = -rhs[10]*(-1)-rhs[114]*(1);
lhs[32] = -rhs[10]*(-1)-rhs[114]*(-1);
lhs[33] = -rhs[11]*(1);
lhs[34] = -rhs[11]*(-1)-rhs[115]*(1);
lhs[35] = -rhs[11]*(-1)-rhs[115]*(-1);
lhs[36] = -rhs[12]*(1);
lhs[37] = -rhs[12]*(-1)-rhs[116]*(1);
lhs[38] = -rhs[12]*(-1)-rhs[116]*(-1);
lhs[39] = -rhs[13]*(1);
lhs[40] = -rhs[13]*(-1)-rhs[117]*(1);
lhs[41] = -rhs[13]*(-1)-rhs[117]*(-1);
lhs[42] = -rhs[14]*(1);
lhs[43] = -rhs[14]*(-1)-rhs[118]*(1);
lhs[44] = -rhs[14]*(-1)-rhs[118]*(-1);
lhs[45] = -rhs[15]*(1);
lhs[46] = -rhs[15]*(-1)-rhs[119]*(1);
lhs[47] = -rhs[15]*(-1)-rhs[119]*(-1);
lhs[48] = -rhs[16]*(1);
lhs[49] = -rhs[16]*(-1)-rhs[120]*(1);
lhs[50] = -rhs[16]*(-1)-rhs[120]*(-1);
lhs[51] = -rhs[17]*(1);
lhs[52] = -rhs[17]*(-1)-rhs[121]*(1);
lhs[53] = -rhs[17]*(-1)-rhs[121]*(-1);
lhs[54] = -rhs[18]*(1);
lhs[55] = -rhs[18]*(-1)-rhs[122]*(1);
lhs[56] = -rhs[18]*(-1)-rhs[122]*(-1);
lhs[57] = -rhs[19]*(1);
lhs[58] = -rhs[19]*(-1)-rhs[123]*(1);
lhs[59] = -rhs[19]*(-1)-rhs[123]*(-1);
lhs[60] = -rhs[20]*(1);
lhs[61] = -rhs[20]*(-1)-rhs[124]*(1);
lhs[62] = -rhs[20]*(-1)-rhs[124]*(-1);
lhs[63] = -rhs[21]*(1);
lhs[64] = -rhs[21]*(-1)-rhs[125]*(1);
lhs[65] = -rhs[21]*(-1)-rhs[125]*(-1);
lhs[66] = -rhs[22]*(1);
lhs[67] = -rhs[22]*(-1)-rhs[126]*(1);
lhs[68] = -rhs[22]*(-1)-rhs[126]*(-1);
lhs[69] = -rhs[23]*(1);
lhs[70] = -rhs[23]*(-1)-rhs[127]*(1);
lhs[71] = -rhs[23]*(-1)-rhs[127]*(-1);
lhs[72] = -rhs[24]*(1);
lhs[73] = -rhs[24]*(-1)-rhs[128]*(1);
lhs[74] = -rhs[24]*(-1)-rhs[128]*(-1);
lhs[75] = -rhs[25]*(1);
lhs[76] = -rhs[25]*(-1)-rhs[129]*(1);
lhs[77] = -rhs[25]*(-1)-rhs[129]*(-1);
lhs[78] = -rhs[26]*(1);
lhs[79] = -rhs[26]*(-1)-rhs[104]*(1);
lhs[80] = -rhs[26]*(-1)-rhs[104]*(-1);
lhs[81] = -rhs[27]*(1);
lhs[82] = -rhs[27]*(-1)-rhs[104]*(-1)-rhs[105]*(1);
lhs[83] = -rhs[27]*(-1)-rhs[104]*(1)-rhs[105]*(-1);
lhs[84] = -rhs[28]*(1);
lhs[85] = -rhs[28]*(-1)-rhs[105]*(-1)-rhs[106]*(1);
lhs[86] = -rhs[28]*(-1)-rhs[105]*(1)-rhs[106]*(-1);
lhs[87] = -rhs[29]*(1);
lhs[88] = -rhs[29]*(-1)-rhs[106]*(-1)-rhs[107]*(1);
lhs[89] = -rhs[29]*(-1)-rhs[106]*(1)-rhs[107]*(-1);
lhs[90] = -rhs[30]*(1);
lhs[91] = -rhs[30]*(-1)-rhs[107]*(-1)-rhs[108]*(1);
lhs[92] = -rhs[30]*(-1)-rhs[107]*(1)-rhs[108]*(-1);
lhs[93] = -rhs[31]*(1);
lhs[94] = -rhs[31]*(-1)-rhs[108]*(-1)-rhs[109]*(1);
lhs[95] = -rhs[31]*(-1)-rhs[108]*(1)-rhs[109]*(-1);
lhs[96] = -rhs[32]*(1);
lhs[97] = -rhs[32]*(-1)-rhs[109]*(-1)-rhs[110]*(1);
lhs[98] = -rhs[32]*(-1)-rhs[109]*(1)-rhs[110]*(-1);
lhs[99] = -rhs[33]*(1);
lhs[100] = -rhs[33]*(-1)-rhs[110]*(-1)-rhs[111]*(1);
lhs[101] = -rhs[33]*(-1)-rhs[110]*(1)-rhs[111]*(-1);
lhs[102] = -rhs[34]*(1);
lhs[103] = -rhs[34]*(-1)-rhs[111]*(-1)-rhs[112]*(1);
lhs[104] = -rhs[34]*(-1)-rhs[111]*(1)-rhs[112]*(-1);
lhs[105] = -rhs[35]*(1);
lhs[106] = -rhs[35]*(-1)-rhs[112]*(-1)-rhs[113]*(1);
lhs[107] = -rhs[35]*(-1)-rhs[112]*(1)-rhs[113]*(-1);
lhs[108] = -rhs[36]*(1);
lhs[109] = -rhs[36]*(-1)-rhs[113]*(-1)-rhs[114]*(1);
lhs[110] = -rhs[36]*(-1)-rhs[113]*(1)-rhs[114]*(-1);
lhs[111] = -rhs[37]*(1);
lhs[112] = -rhs[37]*(-1)-rhs[114]*(-1)-rhs[115]*(1);
lhs[113] = -rhs[37]*(-1)-rhs[114]*(1)-rhs[115]*(-1);
lhs[114] = -rhs[38]*(1);
lhs[115] = -rhs[38]*(-1)-rhs[115]*(-1)-rhs[116]*(1);
lhs[116] = -rhs[38]*(-1)-rhs[115]*(1)-rhs[116]*(-1);
lhs[117] = -rhs[39]*(1);
lhs[118] = -rhs[39]*(-1)-rhs[116]*(-1)-rhs[117]*(1);
lhs[119] = -rhs[39]*(-1)-rhs[116]*(1)-rhs[117]*(-1);
lhs[120] = -rhs[40]*(1);
lhs[121] = -rhs[40]*(-1)-rhs[117]*(-1)-rhs[118]*(1);
lhs[122] = -rhs[40]*(-1)-rhs[117]*(1)-rhs[118]*(-1);
lhs[123] = -rhs[41]*(1);
lhs[124] = -rhs[41]*(-1)-rhs[118]*(-1)-rhs[119]*(1);
lhs[125] = -rhs[41]*(-1)-rhs[118]*(1)-rhs[119]*(-1);
lhs[126] = -rhs[42]*(1);
lhs[127] = -rhs[42]*(-1)-rhs[119]*(-1)-rhs[120]*(1);
lhs[128] = -rhs[42]*(-1)-rhs[119]*(1)-rhs[120]*(-1);
lhs[129] = -rhs[43]*(1);
lhs[130] = -rhs[43]*(-1)-rhs[120]*(-1)-rhs[121]*(1);
lhs[131] = -rhs[43]*(-1)-rhs[120]*(1)-rhs[121]*(-1);
lhs[132] = -rhs[44]*(1);
lhs[133] = -rhs[44]*(-1)-rhs[121]*(-1)-rhs[122]*(1);
lhs[134] = -rhs[44]*(-1)-rhs[121]*(1)-rhs[122]*(-1);
lhs[135] = -rhs[45]*(1);
lhs[136] = -rhs[45]*(-1)-rhs[122]*(-1)-rhs[123]*(1);
lhs[137] = -rhs[45]*(-1)-rhs[122]*(1)-rhs[123]*(-1);
lhs[138] = -rhs[46]*(1);
lhs[139] = -rhs[46]*(-1)-rhs[123]*(-1)-rhs[124]*(1);
lhs[140] = -rhs[46]*(-1)-rhs[123]*(1)-rhs[124]*(-1);
lhs[141] = -rhs[47]*(1);
lhs[142] = -rhs[47]*(-1)-rhs[124]*(-1)-rhs[125]*(1);
lhs[143] = -rhs[47]*(-1)-rhs[124]*(1)-rhs[125]*(-1);
lhs[144] = -rhs[48]*(1);
lhs[145] = -rhs[48]*(-1)-rhs[125]*(-1)-rhs[126]*(1);
lhs[146] = -rhs[48]*(-1)-rhs[125]*(1)-rhs[126]*(-1);
lhs[147] = -rhs[49]*(1);
lhs[148] = -rhs[49]*(-1)-rhs[126]*(-1)-rhs[127]*(1);
lhs[149] = -rhs[49]*(-1)-rhs[126]*(1)-rhs[127]*(-1);
lhs[150] = -rhs[50]*(1);
lhs[151] = -rhs[50]*(-1)-rhs[127]*(-1)-rhs[128]*(1);
lhs[152] = -rhs[50]*(-1)-rhs[127]*(1)-rhs[128]*(-1);
lhs[153] = -rhs[51]*(1);
lhs[154] = -rhs[51]*(-1)-rhs[128]*(-1)-rhs[129]*(1);
lhs[155] = -rhs[51]*(-1)-rhs[128]*(1)-rhs[129]*(-1);
lhs[156] = -rhs[52]*(1);
lhs[157] = -rhs[52]*(-1)-rhs[131]*(1);
lhs[158] = -rhs[52]*(-1)-rhs[131]*(-1);
lhs[159] = -rhs[53]*(1);
lhs[160] = -rhs[53]*(-1)-rhs[134]*(1);
lhs[161] = -rhs[53]*(-1)-rhs[134]*(-1);
lhs[162] = -rhs[54]*(1);
lhs[163] = -rhs[54]*(-1)-rhs[137]*(1);
lhs[164] = -rhs[54]*(-1)-rhs[137]*(-1);
lhs[165] = -rhs[55]*(1);
lhs[166] = -rhs[55]*(-1)-rhs[140]*(1);
lhs[167] = -rhs[55]*(-1)-rhs[140]*(-1);
lhs[168] = -rhs[56]*(1);
lhs[169] = -rhs[56]*(-1)-rhs[143]*(1);
lhs[170] = -rhs[56]*(-1)-rhs[143]*(-1);
lhs[171] = -rhs[57]*(1);
lhs[172] = -rhs[57]*(-1)-rhs[146]*(1);
lhs[173] = -rhs[57]*(-1)-rhs[146]*(-1);
lhs[174] = -rhs[58]*(1);
lhs[175] = -rhs[58]*(-1)-rhs[149]*(1);
lhs[176] = -rhs[58]*(-1)-rhs[149]*(-1);
lhs[177] = -rhs[59]*(1);
lhs[178] = -rhs[59]*(-1)-rhs[152]*(1);
lhs[179] = -rhs[59]*(-1)-rhs[152]*(-1);
lhs[180] = -rhs[60]*(1);
lhs[181] = -rhs[60]*(-1)-rhs[155]*(1);
lhs[182] = -rhs[60]*(-1)-rhs[155]*(-1);
lhs[183] = -rhs[61]*(1);
lhs[184] = -rhs[61]*(-1)-rhs[158]*(1);
lhs[185] = -rhs[61]*(-1)-rhs[158]*(-1);
lhs[186] = -rhs[62]*(1);
lhs[187] = -rhs[62]*(-1)-rhs[161]*(1);
lhs[188] = -rhs[62]*(-1)-rhs[161]*(-1);
lhs[189] = -rhs[63]*(1);
lhs[190] = -rhs[63]*(-1)-rhs[164]*(1);
lhs[191] = -rhs[63]*(-1)-rhs[164]*(-1);
lhs[192] = -rhs[64]*(1);
lhs[193] = -rhs[64]*(-1)-rhs[167]*(1);
lhs[194] = -rhs[64]*(-1)-rhs[167]*(-1);
lhs[195] = -rhs[65]*(1);
lhs[196] = -rhs[65]*(-1)-rhs[170]*(1);
lhs[197] = -rhs[65]*(-1)-rhs[170]*(-1);
lhs[198] = -rhs[66]*(1);
lhs[199] = -rhs[66]*(-1)-rhs[173]*(1);
lhs[200] = -rhs[66]*(-1)-rhs[173]*(-1);
lhs[201] = -rhs[67]*(1);
lhs[202] = -rhs[67]*(-1)-rhs[176]*(1);
lhs[203] = -rhs[67]*(-1)-rhs[176]*(-1);
lhs[204] = -rhs[68]*(1);
lhs[205] = -rhs[68]*(-1)-rhs[179]*(1);
lhs[206] = -rhs[68]*(-1)-rhs[179]*(-1);
lhs[207] = -rhs[69]*(1);
lhs[208] = -rhs[69]*(-1)-rhs[182]*(1);
lhs[209] = -rhs[69]*(-1)-rhs[182]*(-1);
lhs[210] = -rhs[70]*(1);
lhs[211] = -rhs[70]*(-1)-rhs[185]*(1);
lhs[212] = -rhs[70]*(-1)-rhs[185]*(-1);
lhs[213] = -rhs[71]*(1);
lhs[214] = -rhs[71]*(-1)-rhs[188]*(1);
lhs[215] = -rhs[71]*(-1)-rhs[188]*(-1);
lhs[216] = -rhs[72]*(1);
lhs[217] = -rhs[72]*(-1)-rhs[191]*(1);
lhs[218] = -rhs[72]*(-1)-rhs[191]*(-1);
lhs[219] = -rhs[73]*(1);
lhs[220] = -rhs[73]*(-1)-rhs[194]*(1);
lhs[221] = -rhs[73]*(-1)-rhs[194]*(-1);
lhs[222] = -rhs[74]*(1);
lhs[223] = -rhs[74]*(-1)-rhs[197]*(1);
lhs[224] = -rhs[74]*(-1)-rhs[197]*(-1);
lhs[225] = -rhs[75]*(1);
lhs[226] = -rhs[75]*(-1)-rhs[200]*(1);
lhs[227] = -rhs[75]*(-1)-rhs[200]*(-1);
lhs[228] = -rhs[76]*(1);
lhs[229] = -rhs[76]*(-1)-rhs[203]*(1);
lhs[230] = -rhs[76]*(-1)-rhs[203]*(-1);
lhs[231] = -rhs[77]*(1);
lhs[232] = -rhs[77]*(-1)-rhs[206]*(1);
lhs[233] = -rhs[77]*(-1)-rhs[206]*(-1);
lhs[234] = -rhs[78]*(1);
lhs[235] = -rhs[78]*(-1)-rhs[132]*(1);
lhs[236] = -rhs[78]*(-1)-rhs[132]*(-1);
lhs[237] = -rhs[79]*(1);
lhs[238] = -rhs[79]*(-1)-rhs[135]*(1);
lhs[239] = -rhs[79]*(-1)-rhs[135]*(-1);
lhs[240] = -rhs[80]*(1);
lhs[241] = -rhs[80]*(-1)-rhs[138]*(1);
lhs[242] = -rhs[80]*(-1)-rhs[138]*(-1);
lhs[243] = -rhs[81]*(1);
lhs[244] = -rhs[81]*(-1)-rhs[141]*(1);
lhs[245] = -rhs[81]*(-1)-rhs[141]*(-1);
lhs[246] = -rhs[82]*(1);
lhs[247] = -rhs[82]*(-1)-rhs[144]*(1);
lhs[248] = -rhs[82]*(-1)-rhs[144]*(-1);
lhs[249] = -rhs[83]*(1);
lhs[250] = -rhs[83]*(-1)-rhs[147]*(1);
lhs[251] = -rhs[83]*(-1)-rhs[147]*(-1);
lhs[252] = -rhs[84]*(1);
lhs[253] = -rhs[84]*(-1)-rhs[150]*(1);
lhs[254] = -rhs[84]*(-1)-rhs[150]*(-1);
lhs[255] = -rhs[85]*(1);
lhs[256] = -rhs[85]*(-1)-rhs[153]*(1);
lhs[257] = -rhs[85]*(-1)-rhs[153]*(-1);
lhs[258] = -rhs[86]*(1);
lhs[259] = -rhs[86]*(-1)-rhs[156]*(1);
lhs[260] = -rhs[86]*(-1)-rhs[156]*(-1);
lhs[261] = -rhs[87]*(1);
lhs[262] = -rhs[87]*(-1)-rhs[159]*(1);
lhs[263] = -rhs[87]*(-1)-rhs[159]*(-1);
lhs[264] = -rhs[88]*(1);
lhs[265] = -rhs[88]*(-1)-rhs[162]*(1);
lhs[266] = -rhs[88]*(-1)-rhs[162]*(-1);
lhs[267] = -rhs[89]*(1);
lhs[268] = -rhs[89]*(-1)-rhs[165]*(1);
lhs[269] = -rhs[89]*(-1)-rhs[165]*(-1);
lhs[270] = -rhs[90]*(1);
lhs[271] = -rhs[90]*(-1)-rhs[168]*(1);
lhs[272] = -rhs[90]*(-1)-rhs[168]*(-1);
lhs[273] = -rhs[91]*(1);
lhs[274] = -rhs[91]*(-1)-rhs[171]*(1);
lhs[275] = -rhs[91]*(-1)-rhs[171]*(-1);
lhs[276] = -rhs[92]*(1);
lhs[277] = -rhs[92]*(-1)-rhs[174]*(1);
lhs[278] = -rhs[92]*(-1)-rhs[174]*(-1);
lhs[279] = -rhs[93]*(1);
lhs[280] = -rhs[93]*(-1)-rhs[177]*(1);
lhs[281] = -rhs[93]*(-1)-rhs[177]*(-1);
lhs[282] = -rhs[94]*(1);
lhs[283] = -rhs[94]*(-1)-rhs[180]*(1);
lhs[284] = -rhs[94]*(-1)-rhs[180]*(-1);
lhs[285] = -rhs[95]*(1);
lhs[286] = -rhs[95]*(-1)-rhs[183]*(1);
lhs[287] = -rhs[95]*(-1)-rhs[183]*(-1);
lhs[288] = -rhs[96]*(1);
lhs[289] = -rhs[96]*(-1)-rhs[186]*(1);
lhs[290] = -rhs[96]*(-1)-rhs[186]*(-1);
lhs[291] = -rhs[97]*(1);
lhs[292] = -rhs[97]*(-1)-rhs[189]*(1);
lhs[293] = -rhs[97]*(-1)-rhs[189]*(-1);
lhs[294] = -rhs[98]*(1);
lhs[295] = -rhs[98]*(-1)-rhs[192]*(1);
lhs[296] = -rhs[98]*(-1)-rhs[192]*(-1);
lhs[297] = -rhs[99]*(1);
lhs[298] = -rhs[99]*(-1)-rhs[195]*(1);
lhs[299] = -rhs[99]*(-1)-rhs[195]*(-1);
lhs[300] = -rhs[100]*(1);
lhs[301] = -rhs[100]*(-1)-rhs[198]*(1);
lhs[302] = -rhs[100]*(-1)-rhs[198]*(-1);
lhs[303] = -rhs[101]*(1);
lhs[304] = -rhs[101]*(-1)-rhs[201]*(1);
lhs[305] = -rhs[101]*(-1)-rhs[201]*(-1);
lhs[306] = -rhs[102]*(1);
lhs[307] = -rhs[102]*(-1)-rhs[204]*(1);
lhs[308] = -rhs[102]*(-1)-rhs[204]*(-1);
lhs[309] = -rhs[103]*(1);
lhs[310] = -rhs[103]*(-1)-rhs[207]*(1);
lhs[311] = -rhs[103]*(-1)-rhs[207]*(-1);
}
void multbymGT(double *lhs, double *rhs) {
lhs[0] = -rhs[0]*(1)-rhs[1]*(-1)-rhs[2]*(-1);
lhs[1] = -rhs[3]*(1)-rhs[4]*(-1)-rhs[5]*(-1);
lhs[2] = -rhs[6]*(1)-rhs[7]*(-1)-rhs[8]*(-1);
lhs[3] = -rhs[9]*(1)-rhs[10]*(-1)-rhs[11]*(-1);
lhs[4] = -rhs[12]*(1)-rhs[13]*(-1)-rhs[14]*(-1);
lhs[5] = -rhs[15]*(1)-rhs[16]*(-1)-rhs[17]*(-1);
lhs[6] = -rhs[18]*(1)-rhs[19]*(-1)-rhs[20]*(-1);
lhs[7] = -rhs[21]*(1)-rhs[22]*(-1)-rhs[23]*(-1);
lhs[8] = -rhs[24]*(1)-rhs[25]*(-1)-rhs[26]*(-1);
lhs[9] = -rhs[27]*(1)-rhs[28]*(-1)-rhs[29]*(-1);
lhs[10] = -rhs[30]*(1)-rhs[31]*(-1)-rhs[32]*(-1);
lhs[11] = -rhs[33]*(1)-rhs[34]*(-1)-rhs[35]*(-1);
lhs[12] = -rhs[36]*(1)-rhs[37]*(-1)-rhs[38]*(-1);
lhs[13] = -rhs[39]*(1)-rhs[40]*(-1)-rhs[41]*(-1);
lhs[14] = -rhs[42]*(1)-rhs[43]*(-1)-rhs[44]*(-1);
lhs[15] = -rhs[45]*(1)-rhs[46]*(-1)-rhs[47]*(-1);
lhs[16] = -rhs[48]*(1)-rhs[49]*(-1)-rhs[50]*(-1);
lhs[17] = -rhs[51]*(1)-rhs[52]*(-1)-rhs[53]*(-1);
lhs[18] = -rhs[54]*(1)-rhs[55]*(-1)-rhs[56]*(-1);
lhs[19] = -rhs[57]*(1)-rhs[58]*(-1)-rhs[59]*(-1);
lhs[20] = -rhs[60]*(1)-rhs[61]*(-1)-rhs[62]*(-1);
lhs[21] = -rhs[63]*(1)-rhs[64]*(-1)-rhs[65]*(-1);
lhs[22] = -rhs[66]*(1)-rhs[67]*(-1)-rhs[68]*(-1);
lhs[23] = -rhs[69]*(1)-rhs[70]*(-1)-rhs[71]*(-1);
lhs[24] = -rhs[72]*(1)-rhs[73]*(-1)-rhs[74]*(-1);
lhs[25] = -rhs[75]*(1)-rhs[76]*(-1)-rhs[77]*(-1);
lhs[26] = -rhs[78]*(1)-rhs[79]*(-1)-rhs[80]*(-1);
lhs[27] = -rhs[81]*(1)-rhs[82]*(-1)-rhs[83]*(-1);
lhs[28] = -rhs[84]*(1)-rhs[85]*(-1)-rhs[86]*(-1);
lhs[29] = -rhs[87]*(1)-rhs[88]*(-1)-rhs[89]*(-1);
lhs[30] = -rhs[90]*(1)-rhs[91]*(-1)-rhs[92]*(-1);
lhs[31] = -rhs[93]*(1)-rhs[94]*(-1)-rhs[95]*(-1);
lhs[32] = -rhs[96]*(1)-rhs[97]*(-1)-rhs[98]*(-1);
lhs[33] = -rhs[99]*(1)-rhs[100]*(-1)-rhs[101]*(-1);
lhs[34] = -rhs[102]*(1)-rhs[103]*(-1)-rhs[104]*(-1);
lhs[35] = -rhs[105]*(1)-rhs[106]*(-1)-rhs[107]*(-1);
lhs[36] = -rhs[108]*(1)-rhs[109]*(-1)-rhs[110]*(-1);
lhs[37] = -rhs[111]*(1)-rhs[112]*(-1)-rhs[113]*(-1);
lhs[38] = -rhs[114]*(1)-rhs[115]*(-1)-rhs[116]*(-1);
lhs[39] = -rhs[117]*(1)-rhs[118]*(-1)-rhs[119]*(-1);
lhs[40] = -rhs[120]*(1)-rhs[121]*(-1)-rhs[122]*(-1);
lhs[41] = -rhs[123]*(1)-rhs[124]*(-1)-rhs[125]*(-1);
lhs[42] = -rhs[126]*(1)-rhs[127]*(-1)-rhs[128]*(-1);
lhs[43] = -rhs[129]*(1)-rhs[130]*(-1)-rhs[131]*(-1);
lhs[44] = -rhs[132]*(1)-rhs[133]*(-1)-rhs[134]*(-1);
lhs[45] = -rhs[135]*(1)-rhs[136]*(-1)-rhs[137]*(-1);
lhs[46] = -rhs[138]*(1)-rhs[139]*(-1)-rhs[140]*(-1);
lhs[47] = -rhs[141]*(1)-rhs[142]*(-1)-rhs[143]*(-1);
lhs[48] = -rhs[144]*(1)-rhs[145]*(-1)-rhs[146]*(-1);
lhs[49] = -rhs[147]*(1)-rhs[148]*(-1)-rhs[149]*(-1);
lhs[50] = -rhs[150]*(1)-rhs[151]*(-1)-rhs[152]*(-1);
lhs[51] = -rhs[153]*(1)-rhs[154]*(-1)-rhs[155]*(-1);
lhs[52] = -rhs[156]*(1)-rhs[157]*(-1)-rhs[158]*(-1);
lhs[53] = -rhs[159]*(1)-rhs[160]*(-1)-rhs[161]*(-1);
lhs[54] = -rhs[162]*(1)-rhs[163]*(-1)-rhs[164]*(-1);
lhs[55] = -rhs[165]*(1)-rhs[166]*(-1)-rhs[167]*(-1);
lhs[56] = -rhs[168]*(1)-rhs[169]*(-1)-rhs[170]*(-1);
lhs[57] = -rhs[171]*(1)-rhs[172]*(-1)-rhs[173]*(-1);
lhs[58] = -rhs[174]*(1)-rhs[175]*(-1)-rhs[176]*(-1);
lhs[59] = -rhs[177]*(1)-rhs[178]*(-1)-rhs[179]*(-1);
lhs[60] = -rhs[180]*(1)-rhs[181]*(-1)-rhs[182]*(-1);
lhs[61] = -rhs[183]*(1)-rhs[184]*(-1)-rhs[185]*(-1);
lhs[62] = -rhs[186]*(1)-rhs[187]*(-1)-rhs[188]*(-1);
lhs[63] = -rhs[189]*(1)-rhs[190]*(-1)-rhs[191]*(-1);
lhs[64] = -rhs[192]*(1)-rhs[193]*(-1)-rhs[194]*(-1);
lhs[65] = -rhs[195]*(1)-rhs[196]*(-1)-rhs[197]*(-1);
lhs[66] = -rhs[198]*(1)-rhs[199]*(-1)-rhs[200]*(-1);
lhs[67] = -rhs[201]*(1)-rhs[202]*(-1)-rhs[203]*(-1);
lhs[68] = -rhs[204]*(1)-rhs[205]*(-1)-rhs[206]*(-1);
lhs[69] = -rhs[207]*(1)-rhs[208]*(-1)-rhs[209]*(-1);
lhs[70] = -rhs[210]*(1)-rhs[211]*(-1)-rhs[212]*(-1);
lhs[71] = -rhs[213]*(1)-rhs[214]*(-1)-rhs[215]*(-1);
lhs[72] = -rhs[216]*(1)-rhs[217]*(-1)-rhs[218]*(-1);
lhs[73] = -rhs[219]*(1)-rhs[220]*(-1)-rhs[221]*(-1);
lhs[74] = -rhs[222]*(1)-rhs[223]*(-1)-rhs[224]*(-1);
lhs[75] = -rhs[225]*(1)-rhs[226]*(-1)-rhs[227]*(-1);
lhs[76] = -rhs[228]*(1)-rhs[229]*(-1)-rhs[230]*(-1);
lhs[77] = -rhs[231]*(1)-rhs[232]*(-1)-rhs[233]*(-1);
lhs[78] = -rhs[234]*(1)-rhs[235]*(-1)-rhs[236]*(-1);
lhs[79] = -rhs[237]*(1)-rhs[238]*(-1)-rhs[239]*(-1);
lhs[80] = -rhs[240]*(1)-rhs[241]*(-1)-rhs[242]*(-1);
lhs[81] = -rhs[243]*(1)-rhs[244]*(-1)-rhs[245]*(-1);
lhs[82] = -rhs[246]*(1)-rhs[247]*(-1)-rhs[248]*(-1);
lhs[83] = -rhs[249]*(1)-rhs[250]*(-1)-rhs[251]*(-1);
lhs[84] = -rhs[252]*(1)-rhs[253]*(-1)-rhs[254]*(-1);
lhs[85] = -rhs[255]*(1)-rhs[256]*(-1)-rhs[257]*(-1);
lhs[86] = -rhs[258]*(1)-rhs[259]*(-1)-rhs[260]*(-1);
lhs[87] = -rhs[261]*(1)-rhs[262]*(-1)-rhs[263]*(-1);
lhs[88] = -rhs[264]*(1)-rhs[265]*(-1)-rhs[266]*(-1);
lhs[89] = -rhs[267]*(1)-rhs[268]*(-1)-rhs[269]*(-1);
lhs[90] = -rhs[270]*(1)-rhs[271]*(-1)-rhs[272]*(-1);
lhs[91] = -rhs[273]*(1)-rhs[274]*(-1)-rhs[275]*(-1);
lhs[92] = -rhs[276]*(1)-rhs[277]*(-1)-rhs[278]*(-1);
lhs[93] = -rhs[279]*(1)-rhs[280]*(-1)-rhs[281]*(-1);
lhs[94] = -rhs[282]*(1)-rhs[283]*(-1)-rhs[284]*(-1);
lhs[95] = -rhs[285]*(1)-rhs[286]*(-1)-rhs[287]*(-1);
lhs[96] = -rhs[288]*(1)-rhs[289]*(-1)-rhs[290]*(-1);
lhs[97] = -rhs[291]*(1)-rhs[292]*(-1)-rhs[293]*(-1);
lhs[98] = -rhs[294]*(1)-rhs[295]*(-1)-rhs[296]*(-1);
lhs[99] = -rhs[297]*(1)-rhs[298]*(-1)-rhs[299]*(-1);
lhs[100] = -rhs[300]*(1)-rhs[301]*(-1)-rhs[302]*(-1);
lhs[101] = -rhs[303]*(1)-rhs[304]*(-1)-rhs[305]*(-1);
lhs[102] = -rhs[306]*(1)-rhs[307]*(-1)-rhs[308]*(-1);
lhs[103] = -rhs[309]*(1)-rhs[310]*(-1)-rhs[311]*(-1);
lhs[104] = -rhs[1]*(1)-rhs[2]*(-1)-rhs[79]*(1)-rhs[80]*(-1)-rhs[82]*(-1)-rhs[83]*(1);
lhs[105] = -rhs[4]*(1)-rhs[5]*(-1)-rhs[82]*(1)-rhs[83]*(-1)-rhs[85]*(-1)-rhs[86]*(1);
lhs[106] = -rhs[7]*(1)-rhs[8]*(-1)-rhs[85]*(1)-rhs[86]*(-1)-rhs[88]*(-1)-rhs[89]*(1);
lhs[107] = -rhs[10]*(1)-rhs[11]*(-1)-rhs[88]*(1)-rhs[89]*(-1)-rhs[91]*(-1)-rhs[92]*(1);
lhs[108] = -rhs[13]*(1)-rhs[14]*(-1)-rhs[91]*(1)-rhs[92]*(-1)-rhs[94]*(-1)-rhs[95]*(1);
lhs[109] = -rhs[16]*(1)-rhs[17]*(-1)-rhs[94]*(1)-rhs[95]*(-1)-rhs[97]*(-1)-rhs[98]*(1);
lhs[110] = -rhs[19]*(1)-rhs[20]*(-1)-rhs[97]*(1)-rhs[98]*(-1)-rhs[100]*(-1)-rhs[101]*(1);
lhs[111] = -rhs[22]*(1)-rhs[23]*(-1)-rhs[100]*(1)-rhs[101]*(-1)-rhs[103]*(-1)-rhs[104]*(1);
lhs[112] = -rhs[25]*(1)-rhs[26]*(-1)-rhs[103]*(1)-rhs[104]*(-1)-rhs[106]*(-1)-rhs[107]*(1);
lhs[113] = -rhs[28]*(1)-rhs[29]*(-1)-rhs[106]*(1)-rhs[107]*(-1)-rhs[109]*(-1)-rhs[110]*(1);
lhs[114] = -rhs[31]*(1)-rhs[32]*(-1)-rhs[109]*(1)-rhs[110]*(-1)-rhs[112]*(-1)-rhs[113]*(1);
lhs[115] = -rhs[34]*(1)-rhs[35]*(-1)-rhs[112]*(1)-rhs[113]*(-1)-rhs[115]*(-1)-rhs[116]*(1);
lhs[116] = -rhs[37]*(1)-rhs[38]*(-1)-rhs[115]*(1)-rhs[116]*(-1)-rhs[118]*(-1)-rhs[119]*(1);
lhs[117] = -rhs[40]*(1)-rhs[41]*(-1)-rhs[118]*(1)-rhs[119]*(-1)-rhs[121]*(-1)-rhs[122]*(1);
lhs[118] = -rhs[43]*(1)-rhs[44]*(-1)-rhs[121]*(1)-rhs[122]*(-1)-rhs[124]*(-1)-rhs[125]*(1);
lhs[119] = -rhs[46]*(1)-rhs[47]*(-1)-rhs[124]*(1)-rhs[125]*(-1)-rhs[127]*(-1)-rhs[128]*(1);
lhs[120] = -rhs[49]*(1)-rhs[50]*(-1)-rhs[127]*(1)-rhs[128]*(-1)-rhs[130]*(-1)-rhs[131]*(1);
lhs[121] = -rhs[52]*(1)-rhs[53]*(-1)-rhs[130]*(1)-rhs[131]*(-1)-rhs[133]*(-1)-rhs[134]*(1);
lhs[122] = -rhs[55]*(1)-rhs[56]*(-1)-rhs[133]*(1)-rhs[134]*(-1)-rhs[136]*(-1)-rhs[137]*(1);
lhs[123] = -rhs[58]*(1)-rhs[59]*(-1)-rhs[136]*(1)-rhs[137]*(-1)-rhs[139]*(-1)-rhs[140]*(1);
lhs[124] = -rhs[61]*(1)-rhs[62]*(-1)-rhs[139]*(1)-rhs[140]*(-1)-rhs[142]*(-1)-rhs[143]*(1);
lhs[125] = -rhs[64]*(1)-rhs[65]*(-1)-rhs[142]*(1)-rhs[143]*(-1)-rhs[145]*(-1)-rhs[146]*(1);
lhs[126] = -rhs[67]*(1)-rhs[68]*(-1)-rhs[145]*(1)-rhs[146]*(-1)-rhs[148]*(-1)-rhs[149]*(1);
lhs[127] = -rhs[70]*(1)-rhs[71]*(-1)-rhs[148]*(1)-rhs[149]*(-1)-rhs[151]*(-1)-rhs[152]*(1);
lhs[128] = -rhs[73]*(1)-rhs[74]*(-1)-rhs[151]*(1)-rhs[152]*(-1)-rhs[154]*(-1)-rhs[155]*(1);
lhs[129] = -rhs[76]*(1)-rhs[77]*(-1)-rhs[154]*(1)-rhs[155]*(-1);
lhs[130] = 0;
lhs[131] = -rhs[157]*(1)-rhs[158]*(-1);
lhs[132] = -rhs[235]*(1)-rhs[236]*(-1);
lhs[133] = 0;
lhs[134] = -rhs[160]*(1)-rhs[161]*(-1);
lhs[135] = -rhs[238]*(1)-rhs[239]*(-1);
lhs[136] = 0;
lhs[137] = -rhs[163]*(1)-rhs[164]*(-1);
lhs[138] = -rhs[241]*(1)-rhs[242]*(-1);
lhs[139] = 0;
lhs[140] = -rhs[166]*(1)-rhs[167]*(-1);
lhs[141] = -rhs[244]*(1)-rhs[245]*(-1);
lhs[142] = 0;
lhs[143] = -rhs[169]*(1)-rhs[170]*(-1);
lhs[144] = -rhs[247]*(1)-rhs[248]*(-1);
lhs[145] = 0;
lhs[146] = -rhs[172]*(1)-rhs[173]*(-1);
lhs[147] = -rhs[250]*(1)-rhs[251]*(-1);
lhs[148] = 0;
lhs[149] = -rhs[175]*(1)-rhs[176]*(-1);
lhs[150] = -rhs[253]*(1)-rhs[254]*(-1);
lhs[151] = 0;
lhs[152] = -rhs[178]*(1)-rhs[179]*(-1);
lhs[153] = -rhs[256]*(1)-rhs[257]*(-1);
lhs[154] = 0;
lhs[155] = -rhs[181]*(1)-rhs[182]*(-1);
lhs[156] = -rhs[259]*(1)-rhs[260]*(-1);
lhs[157] = 0;
lhs[158] = -rhs[184]*(1)-rhs[185]*(-1);
lhs[159] = -rhs[262]*(1)-rhs[263]*(-1);
lhs[160] = 0;
lhs[161] = -rhs[187]*(1)-rhs[188]*(-1);
lhs[162] = -rhs[265]*(1)-rhs[266]*(-1);
lhs[163] = 0;
lhs[164] = -rhs[190]*(1)-rhs[191]*(-1);
lhs[165] = -rhs[268]*(1)-rhs[269]*(-1);
lhs[166] = 0;
lhs[167] = -rhs[193]*(1)-rhs[194]*(-1);
lhs[168] = -rhs[271]*(1)-rhs[272]*(-1);
lhs[169] = 0;
lhs[170] = -rhs[196]*(1)-rhs[197]*(-1);
lhs[171] = -rhs[274]*(1)-rhs[275]*(-1);
lhs[172] = 0;
lhs[173] = -rhs[199]*(1)-rhs[200]*(-1);
lhs[174] = -rhs[277]*(1)-rhs[278]*(-1);
lhs[175] = 0;
lhs[176] = -rhs[202]*(1)-rhs[203]*(-1);
lhs[177] = -rhs[280]*(1)-rhs[281]*(-1);
lhs[178] = 0;
lhs[179] = -rhs[205]*(1)-rhs[206]*(-1);
lhs[180] = -rhs[283]*(1)-rhs[284]*(-1);
lhs[181] = 0;
lhs[182] = -rhs[208]*(1)-rhs[209]*(-1);
lhs[183] = -rhs[286]*(1)-rhs[287]*(-1);
lhs[184] = 0;
lhs[185] = -rhs[211]*(1)-rhs[212]*(-1);
lhs[186] = -rhs[289]*(1)-rhs[290]*(-1);
lhs[187] = 0;
lhs[188] = -rhs[214]*(1)-rhs[215]*(-1);
lhs[189] = -rhs[292]*(1)-rhs[293]*(-1);
lhs[190] = 0;
lhs[191] = -rhs[217]*(1)-rhs[218]*(-1);
lhs[192] = -rhs[295]*(1)-rhs[296]*(-1);
lhs[193] = 0;
lhs[194] = -rhs[220]*(1)-rhs[221]*(-1);
lhs[195] = -rhs[298]*(1)-rhs[299]*(-1);
lhs[196] = 0;
lhs[197] = -rhs[223]*(1)-rhs[224]*(-1);
lhs[198] = -rhs[301]*(1)-rhs[302]*(-1);
lhs[199] = 0;
lhs[200] = -rhs[226]*(1)-rhs[227]*(-1);
lhs[201] = -rhs[304]*(1)-rhs[305]*(-1);
lhs[202] = 0;
lhs[203] = -rhs[229]*(1)-rhs[230]*(-1);
lhs[204] = -rhs[307]*(1)-rhs[308]*(-1);
lhs[205] = 0;
lhs[206] = -rhs[232]*(1)-rhs[233]*(-1);
lhs[207] = -rhs[310]*(1)-rhs[311]*(-1);
}
void multbyP(double *lhs, double *rhs) {
/* TODO use the fact that P is symmetric? */
/* TODO check doubling / half factor etc. */
lhs[0] = 0;
lhs[1] = 0;
lhs[2] = 0;
lhs[3] = 0;
lhs[4] = 0;
lhs[5] = 0;
lhs[6] = 0;
lhs[7] = 0;
lhs[8] = 0;
lhs[9] = 0;
lhs[10] = 0;
lhs[11] = 0;
lhs[12] = 0;
lhs[13] = 0;
lhs[14] = 0;
lhs[15] = 0;
lhs[16] = 0;
lhs[17] = 0;
lhs[18] = 0;
lhs[19] = 0;
lhs[20] = 0;
lhs[21] = 0;
lhs[22] = 0;
lhs[23] = 0;
lhs[24] = 0;
lhs[25] = 0;
lhs[26] = 0;
lhs[27] = 0;
lhs[28] = 0;
lhs[29] = 0;
lhs[30] = 0;
lhs[31] = 0;
lhs[32] = 0;
lhs[33] = 0;
lhs[34] = 0;
lhs[35] = 0;
lhs[36] = 0;
lhs[37] = 0;
lhs[38] = 0;
lhs[39] = 0;
lhs[40] = 0;
lhs[41] = 0;
lhs[42] = 0;
lhs[43] = 0;
lhs[44] = 0;
lhs[45] = 0;
lhs[46] = 0;
lhs[47] = 0;
lhs[48] = 0;
lhs[49] = 0;
lhs[50] = 0;
lhs[51] = 0;
lhs[52] = 0;
lhs[53] = 0;
lhs[54] = 0;
lhs[55] = 0;
lhs[56] = 0;
lhs[57] = 0;
lhs[58] = 0;
lhs[59] = 0;
lhs[60] = 0;
lhs[61] = 0;
lhs[62] = 0;
lhs[63] = 0;
lhs[64] = 0;
lhs[65] = 0;
lhs[66] = 0;
lhs[67] = 0;
lhs[68] = 0;
lhs[69] = 0;
lhs[70] = 0;
lhs[71] = 0;
lhs[72] = 0;
lhs[73] = 0;
lhs[74] = 0;
lhs[75] = 0;
lhs[76] = 0;
lhs[77] = 0;
lhs[78] = 0;
lhs[79] = 0;
lhs[80] = 0;
lhs[81] = 0;
lhs[82] = 0;
lhs[83] = 0;
lhs[84] = 0;
lhs[85] = 0;
lhs[86] = 0;
lhs[87] = 0;
lhs[88] = 0;
lhs[89] = 0;
lhs[90] = 0;
lhs[91] = 0;
lhs[92] = 0;
lhs[93] = 0;
lhs[94] = 0;
lhs[95] = 0;
lhs[96] = 0;
lhs[97] = 0;
lhs[98] = 0;
lhs[99] = 0;
lhs[100] = 0;
lhs[101] = 0;
lhs[102] = 0;
lhs[103] = 0;
lhs[104] = 0;
lhs[105] = 0;
lhs[106] = 0;
lhs[107] = 0;
lhs[108] = 0;
lhs[109] = 0;
lhs[110] = 0;
lhs[111] = 0;
lhs[112] = 0;
lhs[113] = 0;
lhs[114] = 0;
lhs[115] = 0;
lhs[116] = 0;
lhs[117] = 0;
lhs[118] = 0;
lhs[119] = 0;
lhs[120] = 0;
lhs[121] = 0;
lhs[122] = 0;
lhs[123] = 0;
lhs[124] = 0;
lhs[125] = 0;
lhs[126] = 0;
lhs[127] = 0;
lhs[128] = 0;
lhs[129] = 0;
lhs[130] = rhs[130]*(2*params.Q[0]);
lhs[131] = rhs[131]*(2*params.Q[1]);
lhs[132] = rhs[132]*(2*params.Q[2]);
lhs[133] = rhs[133]*(2*params.Q[0]);
lhs[134] = rhs[134]*(2*params.Q[1]);
lhs[135] = rhs[135]*(2*params.Q[2]);
lhs[136] = rhs[136]*(2*params.Q[0]);
lhs[137] = rhs[137]*(2*params.Q[1]);
lhs[138] = rhs[138]*(2*params.Q[2]);
lhs[139] = rhs[139]*(2*params.Q[0]);
lhs[140] = rhs[140]*(2*params.Q[1]);
lhs[141] = rhs[141]*(2*params.Q[2]);
lhs[142] = rhs[142]*(2*params.Q[0]);
lhs[143] = rhs[143]*(2*params.Q[1]);
lhs[144] = rhs[144]*(2*params.Q[2]);
lhs[145] = rhs[145]*(2*params.Q[0]);
lhs[146] = rhs[146]*(2*params.Q[1]);
lhs[147] = rhs[147]*(2*params.Q[2]);
lhs[148] = rhs[148]*(2*params.Q[0]);
lhs[149] = rhs[149]*(2*params.Q[1]);
lhs[150] = rhs[150]*(2*params.Q[2]);
lhs[151] = rhs[151]*(2*params.Q[0]);
lhs[152] = rhs[152]*(2*params.Q[1]);
lhs[153] = rhs[153]*(2*params.Q[2]);
lhs[154] = rhs[154]*(2*params.Q[0]);
lhs[155] = rhs[155]*(2*params.Q[1]);
lhs[156] = rhs[156]*(2*params.Q[2]);
lhs[157] = rhs[157]*(2*params.Q[0]);
lhs[158] = rhs[158]*(2*params.Q[1]);
lhs[159] = rhs[159]*(2*params.Q[2]);
lhs[160] = rhs[160]*(2*params.Q[0]);
lhs[161] = rhs[161]*(2*params.Q[1]);
lhs[162] = rhs[162]*(2*params.Q[2]);
lhs[163] = rhs[163]*(2*params.Q[0]);
lhs[164] = rhs[164]*(2*params.Q[1]);
lhs[165] = rhs[165]*(2*params.Q[2]);
lhs[166] = rhs[166]*(2*params.Q[0]);
lhs[167] = rhs[167]*(2*params.Q[1]);
lhs[168] = rhs[168]*(2*params.Q[2]);
lhs[169] = rhs[169]*(2*params.Q[0]);
lhs[170] = rhs[170]*(2*params.Q[1]);
lhs[171] = rhs[171]*(2*params.Q[2]);
lhs[172] = rhs[172]*(2*params.Q[0]);
lhs[173] = rhs[173]*(2*params.Q[1]);
lhs[174] = rhs[174]*(2*params.Q[2]);
lhs[175] = rhs[175]*(2*params.Q[0]);
lhs[176] = rhs[176]*(2*params.Q[1]);
lhs[177] = rhs[177]*(2*params.Q[2]);
lhs[178] = rhs[178]*(2*params.Q[0]);
lhs[179] = rhs[179]*(2*params.Q[1]);
lhs[180] = rhs[180]*(2*params.Q[2]);
lhs[181] = rhs[181]*(2*params.Q[0]);
lhs[182] = rhs[182]*(2*params.Q[1]);
lhs[183] = rhs[183]*(2*params.Q[2]);
lhs[184] = rhs[184]*(2*params.Q[0]);
lhs[185] = rhs[185]*(2*params.Q[1]);
lhs[186] = rhs[186]*(2*params.Q[2]);
lhs[187] = rhs[187]*(2*params.Q[0]);
lhs[188] = rhs[188]*(2*params.Q[1]);
lhs[189] = rhs[189]*(2*params.Q[2]);
lhs[190] = rhs[190]*(2*params.Q[0]);
lhs[191] = rhs[191]*(2*params.Q[1]);
lhs[192] = rhs[192]*(2*params.Q[2]);
lhs[193] = rhs[193]*(2*params.Q[0]);
lhs[194] = rhs[194]*(2*params.Q[1]);
lhs[195] = rhs[195]*(2*params.Q[2]);
lhs[196] = rhs[196]*(2*params.Q[0]);
lhs[197] = rhs[197]*(2*params.Q[1]);
lhs[198] = rhs[198]*(2*params.Q[2]);
lhs[199] = rhs[199]*(2*params.Q[0]);
lhs[200] = rhs[200]*(2*params.Q[1]);
lhs[201] = rhs[201]*(2*params.Q[2]);
lhs[202] = rhs[202]*(2*params.Q[0]);
lhs[203] = rhs[203]*(2*params.Q[1]);
lhs[204] = rhs[204]*(2*params.Q[2]);
lhs[205] = rhs[205]*(2*params.Q_last[0]);
lhs[206] = rhs[206]*(2*params.Q_last[1]);
lhs[207] = rhs[207]*(2*params.Q_last[2]);
}
void fillq(void) {
work.q[0] = 0;
work.q[1] = 0;
work.q[2] = 0;
work.q[3] = 0;
work.q[4] = 0;
work.q[5] = 0;
work.q[6] = 0;
work.q[7] = 0;
work.q[8] = 0;
work.q[9] = 0;
work.q[10] = 0;
work.q[11] = 0;
work.q[12] = 0;
work.q[13] = 0;
work.q[14] = 0;
work.q[15] = 0;
work.q[16] = 0;
work.q[17] = 0;
work.q[18] = 0;
work.q[19] = 0;
work.q[20] = 0;
work.q[21] = 0;
work.q[22] = 0;
work.q[23] = 0;
work.q[24] = 0;
work.q[25] = 0;
work.q[26] = 0;
work.q[27] = 0;
work.q[28] = 0;
work.q[29] = 0;
work.q[30] = 0;
work.q[31] = 0;
work.q[32] = 0;
work.q[33] = 0;
work.q[34] = 0;
work.q[35] = 0;
work.q[36] = 0;
work.q[37] = 0;
work.q[38] = 0;
work.q[39] = 0;
work.q[40] = 0;
work.q[41] = 0;
work.q[42] = 0;
work.q[43] = 0;
work.q[44] = 0;
work.q[45] = 0;
work.q[46] = 0;
work.q[47] = 0;
work.q[48] = 0;
work.q[49] = 0;
work.q[50] = 0;
work.q[51] = 0;
work.q[52] = 0;
work.q[53] = 0;
work.q[54] = 0;
work.q[55] = 0;
work.q[56] = 0;
work.q[57] = 0;
work.q[58] = 0;
work.q[59] = 0;
work.q[60] = 0;
work.q[61] = 0;
work.q[62] = 0;
work.q[63] = 0;
work.q[64] = 0;
work.q[65] = 0;
work.q[66] = 0;
work.q[67] = 0;
work.q[68] = 0;
work.q[69] = 0;
work.q[70] = 0;
work.q[71] = 0;
work.q[72] = 0;
work.q[73] = 0;
work.q[74] = 0;
work.q[75] = 0;
work.q[76] = 0;
work.q[77] = 0;
work.q[78] = 0;
work.q[79] = 0;
work.q[80] = 0;
work.q[81] = 0;
work.q[82] = 0;
work.q[83] = 0;
work.q[84] = 0;
work.q[85] = 0;
work.q[86] = 0;
work.q[87] = 0;
work.q[88] = 0;
work.q[89] = 0;
work.q[90] = 0;
work.q[91] = 0;
work.q[92] = 0;
work.q[93] = 0;
work.q[94] = 0;
work.q[95] = 0;
work.q[96] = 0;
work.q[97] = 0;
work.q[98] = 0;
work.q[99] = 0;
work.q[100] = 0;
work.q[101] = 0;
work.q[102] = 0;
work.q[103] = 0;
work.q[104] = 0;
work.q[105] = 0;
work.q[106] = 0;
work.q[107] = 0;
work.q[108] = 0;
work.q[109] = 0;
work.q[110] = 0;
work.q[111] = 0;
work.q[112] = 0;
work.q[113] = 0;
work.q[114] = 0;
work.q[115] = 0;
work.q[116] = 0;
work.q[117] = 0;
work.q[118] = 0;
work.q[119] = 0;
work.q[120] = 0;
work.q[121] = 0;
work.q[122] = 0;
work.q[123] = 0;
work.q[124] = 0;
work.q[125] = 0;
work.q[126] = 0;
work.q[127] = 0;
work.q[128] = 0;
work.q[129] = 0;
work.q[130] = -2*params.Q[0]*params.x_ss_1[0];
work.q[131] = -2*params.Q[1]*params.x_ss_1[1];
work.q[132] = -2*params.Q[2]*params.x_ss_1[2];
work.q[133] = -2*params.Q[0]*params.x_ss_2[0];
work.q[134] = -2*params.Q[1]*params.x_ss_2[1];
work.q[135] = -2*params.Q[2]*params.x_ss_2[2];
work.q[136] = -2*params.Q[0]*params.x_ss_3[0];
work.q[137] = -2*params.Q[1]*params.x_ss_3[1];
work.q[138] = -2*params.Q[2]*params.x_ss_3[2];
work.q[139] = -2*params.Q[0]*params.x_ss_4[0];
work.q[140] = -2*params.Q[1]*params.x_ss_4[1];
work.q[141] = -2*params.Q[2]*params.x_ss_4[2];
work.q[142] = -2*params.Q[0]*params.x_ss_5[0];
work.q[143] = -2*params.Q[1]*params.x_ss_5[1];
work.q[144] = -2*params.Q[2]*params.x_ss_5[2];
work.q[145] = -2*params.Q[0]*params.x_ss_6[0];
work.q[146] = -2*params.Q[1]*params.x_ss_6[1];
work.q[147] = -2*params.Q[2]*params.x_ss_6[2];
work.q[148] = -2*params.Q[0]*params.x_ss_7[0];
work.q[149] = -2*params.Q[1]*params.x_ss_7[1];
work.q[150] = -2*params.Q[2]*params.x_ss_7[2];
work.q[151] = -2*params.Q[0]*params.x_ss_8[0];
work.q[152] = -2*params.Q[1]*params.x_ss_8[1];
work.q[153] = -2*params.Q[2]*params.x_ss_8[2];
work.q[154] = -2*params.Q[0]*params.x_ss_9[0];
work.q[155] = -2*params.Q[1]*params.x_ss_9[1];
work.q[156] = -2*params.Q[2]*params.x_ss_9[2];
work.q[157] = -2*params.Q[0]*params.x_ss_10[0];
work.q[158] = -2*params.Q[1]*params.x_ss_10[1];
work.q[159] = -2*params.Q[2]*params.x_ss_10[2];
work.q[160] = -2*params.Q[0]*params.x_ss_11[0];
work.q[161] = -2*params.Q[1]*params.x_ss_11[1];
work.q[162] = -2*params.Q[2]*params.x_ss_11[2];
work.q[163] = -2*params.Q[0]*params.x_ss_12[0];
work.q[164] = -2*params.Q[1]*params.x_ss_12[1];
work.q[165] = -2*params.Q[2]*params.x_ss_12[2];
work.q[166] = -2*params.Q[0]*params.x_ss_13[0];
work.q[167] = -2*params.Q[1]*params.x_ss_13[1];
work.q[168] = -2*params.Q[2]*params.x_ss_13[2];
work.q[169] = -2*params.Q[0]*params.x_ss_14[0];
work.q[170] = -2*params.Q[1]*params.x_ss_14[1];
work.q[171] = -2*params.Q[2]*params.x_ss_14[2];
work.q[172] = -2*params.Q[0]*params.x_ss_15[0];
work.q[173] = -2*params.Q[1]*params.x_ss_15[1];
work.q[174] = -2*params.Q[2]*params.x_ss_15[2];
work.q[175] = -2*params.Q[0]*params.x_ss_16[0];
work.q[176] = -2*params.Q[1]*params.x_ss_16[1];
work.q[177] = -2*params.Q[2]*params.x_ss_16[2];
work.q[178] = -2*params.Q[0]*params.x_ss_17[0];
work.q[179] = -2*params.Q[1]*params.x_ss_17[1];
work.q[180] = -2*params.Q[2]*params.x_ss_17[2];
work.q[181] = -2*params.Q[0]*params.x_ss_18[0];
work.q[182] = -2*params.Q[1]*params.x_ss_18[1];
work.q[183] = -2*params.Q[2]*params.x_ss_18[2];
work.q[184] = -2*params.Q[0]*params.x_ss_19[0];
work.q[185] = -2*params.Q[1]*params.x_ss_19[1];
work.q[186] = -2*params.Q[2]*params.x_ss_19[2];
work.q[187] = -2*params.Q[0]*params.x_ss_20[0];
work.q[188] = -2*params.Q[1]*params.x_ss_20[1];
work.q[189] = -2*params.Q[2]*params.x_ss_20[2];
work.q[190] = -2*params.Q[0]*params.x_ss_21[0];
work.q[191] = -2*params.Q[1]*params.x_ss_21[1];
work.q[192] = -2*params.Q[2]*params.x_ss_21[2];
work.q[193] = -2*params.Q[0]*params.x_ss_22[0];
work.q[194] = -2*params.Q[1]*params.x_ss_22[1];
work.q[195] = -2*params.Q[2]*params.x_ss_22[2];
work.q[196] = -2*params.Q[0]*params.x_ss_23[0];
work.q[197] = -2*params.Q[1]*params.x_ss_23[1];
work.q[198] = -2*params.Q[2]*params.x_ss_23[2];
work.q[199] = -2*params.Q[0]*params.x_ss_24[0];
work.q[200] = -2*params.Q[1]*params.x_ss_24[1];
work.q[201] = -2*params.Q[2]*params.x_ss_24[2];
work.q[202] = -2*params.Q[0]*params.x_ss_25[0];
work.q[203] = -2*params.Q[1]*params.x_ss_25[1];
work.q[204] = -2*params.Q[2]*params.x_ss_25[2];
work.q[205] = -2*params.Q_last[0]*params.x_ss_26[0];
work.q[206] = -2*params.Q_last[1]*params.x_ss_26[1];
work.q[207] = -2*params.Q_last[2]*params.x_ss_26[2];
}
void fillh(void) {
work.h[0] = params.u_max[0];
work.h[1] = 0;
work.h[2] = 0;
work.h[3] = params.u_max[0];
work.h[4] = 0;
work.h[5] = 0;
work.h[6] = params.u_max[0];
work.h[7] = 0;
work.h[8] = 0;
work.h[9] = params.u_max[0];
work.h[10] = 0;
work.h[11] = 0;
work.h[12] = params.u_max[0];
work.h[13] = 0;
work.h[14] = 0;
work.h[15] = params.u_max[0];
work.h[16] = 0;
work.h[17] = 0;
work.h[18] = params.u_max[0];
work.h[19] = 0;
work.h[20] = 0;
work.h[21] = params.u_max[0];
work.h[22] = 0;
work.h[23] = 0;
work.h[24] = params.u_max[0];
work.h[25] = 0;
work.h[26] = 0;
work.h[27] = params.u_max[0];
work.h[28] = 0;
work.h[29] = 0;
work.h[30] = params.u_max[0];
work.h[31] = 0;
work.h[32] = 0;
work.h[33] = params.u_max[0];
work.h[34] = 0;
work.h[35] = 0;
work.h[36] = params.u_max[0];
work.h[37] = 0;
work.h[38] = 0;
work.h[39] = params.u_max[0];
work.h[40] = 0;
work.h[41] = 0;
work.h[42] = params.u_max[0];
work.h[43] = 0;
work.h[44] = 0;
work.h[45] = params.u_max[0];
work.h[46] = 0;
work.h[47] = 0;
work.h[48] = params.u_max[0];
work.h[49] = 0;
work.h[50] = 0;
work.h[51] = params.u_max[0];
work.h[52] = 0;
work.h[53] = 0;
work.h[54] = params.u_max[0];
work.h[55] = 0;
work.h[56] = 0;
work.h[57] = params.u_max[0];
work.h[58] = 0;
work.h[59] = 0;
work.h[60] = params.u_max[0];
work.h[61] = 0;
work.h[62] = 0;
work.h[63] = params.u_max[0];
work.h[64] = 0;
work.h[65] = 0;
work.h[66] = params.u_max[0];
work.h[67] = 0;
work.h[68] = 0;
work.h[69] = params.u_max[0];
work.h[70] = 0;
work.h[71] = 0;
work.h[72] = params.u_max[0];
work.h[73] = 0;
work.h[74] = 0;
work.h[75] = params.u_max[0];
work.h[76] = 0;
work.h[77] = 0;
work.h[78] = params.du_max_f[0];
work.h[79] = params.u_last[0];
work.h[80] = -params.u_last[0];
work.h[81] = params.du_max[0];
work.h[82] = 0;
work.h[83] = 0;
work.h[84] = params.du_max[0];
work.h[85] = 0;
work.h[86] = 0;
work.h[87] = params.du_max[0];
work.h[88] = 0;
work.h[89] = 0;
work.h[90] = params.du_max[0];
work.h[91] = 0;
work.h[92] = 0;
work.h[93] = params.du_max[0];
work.h[94] = 0;
work.h[95] = 0;
work.h[96] = params.du_max[0];
work.h[97] = 0;
work.h[98] = 0;
work.h[99] = params.du_max[0];
work.h[100] = 0;
work.h[101] = 0;
work.h[102] = params.du_max[0];
work.h[103] = 0;
work.h[104] = 0;
work.h[105] = params.du_max[0];
work.h[106] = 0;
work.h[107] = 0;
work.h[108] = params.du_max[0];
work.h[109] = 0;
work.h[110] = 0;
work.h[111] = params.du_max[0];
work.h[112] = 0;
work.h[113] = 0;
work.h[114] = params.du_max[0];
work.h[115] = 0;
work.h[116] = 0;
work.h[117] = params.du_max[0];
work.h[118] = 0;
work.h[119] = 0;
work.h[120] = params.du_max[0];
work.h[121] = 0;
work.h[122] = 0;
work.h[123] = params.du_max[0];
work.h[124] = 0;
work.h[125] = 0;
work.h[126] = params.du_max[0];
work.h[127] = 0;
work.h[128] = 0;
work.h[129] = params.du_max[0];
work.h[130] = 0;
work.h[131] = 0;
work.h[132] = params.du_max[0];
work.h[133] = 0;
work.h[134] = 0;
work.h[135] = params.du_max[0];
work.h[136] = 0;
work.h[137] = 0;
work.h[138] = params.du_max[0];
work.h[139] = 0;
work.h[140] = 0;
work.h[141] = params.du_max[0];
work.h[142] = 0;
work.h[143] = 0;
work.h[144] = params.du_max[0];
work.h[145] = 0;
work.h[146] = 0;
work.h[147] = params.du_max[0];
work.h[148] = 0;
work.h[149] = 0;
work.h[150] = params.du_max[0];
work.h[151] = 0;
work.h[152] = 0;
work.h[153] = params.du_max[0];
work.h[154] = 0;
work.h[155] = 0;
work.h[156] = params.x_max_2[0];
work.h[157] = 0;
work.h[158] = 0;
work.h[159] = params.x_max_2[0];
work.h[160] = 0;
work.h[161] = 0;
work.h[162] = params.x_max_2[0];
work.h[163] = 0;
work.h[164] = 0;
work.h[165] = params.x_max_2[0];
work.h[166] = 0;
work.h[167] = 0;
work.h[168] = params.x_max_2[0];
work.h[169] = 0;
work.h[170] = 0;
work.h[171] = params.x_max_2[0];
work.h[172] = 0;
work.h[173] = 0;
work.h[174] = params.x_max_2[0];
work.h[175] = 0;
work.h[176] = 0;
work.h[177] = params.x_max_2[0];
work.h[178] = 0;
work.h[179] = 0;
work.h[180] = params.x_max_2[0];
work.h[181] = 0;
work.h[182] = 0;
work.h[183] = params.x_max_2[0];
work.h[184] = 0;
work.h[185] = 0;
work.h[186] = params.x_max_2[0];
work.h[187] = 0;
work.h[188] = 0;
work.h[189] = params.x_max_2[0];
work.h[190] = 0;
work.h[191] = 0;
work.h[192] = params.x_max_2[0];
work.h[193] = 0;
work.h[194] = 0;
work.h[195] = params.x_max_2[0];
work.h[196] = 0;
work.h[197] = 0;
work.h[198] = params.x_max_2[0];
work.h[199] = 0;
work.h[200] = 0;
work.h[201] = params.x_max_2[0];
work.h[202] = 0;
work.h[203] = 0;
work.h[204] = params.x_max_2[0];
work.h[205] = 0;
work.h[206] = 0;
work.h[207] = params.x_max_2[0];
work.h[208] = 0;
work.h[209] = 0;
work.h[210] = params.x_max_2[0];
work.h[211] = 0;
work.h[212] = 0;
work.h[213] = params.x_max_2[0];
work.h[214] = 0;
work.h[215] = 0;
work.h[216] = params.x_max_2[0];
work.h[217] = 0;
work.h[218] = 0;
work.h[219] = params.x_max_2[0];
work.h[220] = 0;
work.h[221] = 0;
work.h[222] = params.x_max_2[0];
work.h[223] = 0;
work.h[224] = 0;
work.h[225] = params.x_max_2[0];
work.h[226] = 0;
work.h[227] = 0;
work.h[228] = params.x_max_2[0];
work.h[229] = 0;
work.h[230] = 0;
work.h[231] = params.x_max_2[0];
work.h[232] = 0;
work.h[233] = 0;
work.h[234] = params.x_max_3[0];
work.h[235] = 0;
work.h[236] = 0;
work.h[237] = params.x_max_3[0];
work.h[238] = 0;
work.h[239] = 0;
work.h[240] = params.x_max_3[0];
work.h[241] = 0;
work.h[242] = 0;
work.h[243] = params.x_max_3[0];
work.h[244] = 0;
work.h[245] = 0;
work.h[246] = params.x_max_3[0];
work.h[247] = 0;
work.h[248] = 0;
work.h[249] = params.x_max_3[0];
work.h[250] = 0;
work.h[251] = 0;
work.h[252] = params.x_max_3[0];
work.h[253] = 0;
work.h[254] = 0;
work.h[255] = params.x_max_3[0];
work.h[256] = 0;
work.h[257] = 0;
work.h[258] = params.x_max_3[0];
work.h[259] = 0;
work.h[260] = 0;
work.h[261] = params.x_max_3[0];
work.h[262] = 0;
work.h[263] = 0;
work.h[264] = params.x_max_3[0];
work.h[265] = 0;
work.h[266] = 0;
work.h[267] = params.x_max_3[0];
work.h[268] = 0;
work.h[269] = 0;
work.h[270] = params.x_max_3[0];
work.h[271] = 0;
work.h[272] = 0;
work.h[273] = params.x_max_3[0];
work.h[274] = 0;
work.h[275] = 0;
work.h[276] = params.x_max_3[0];
work.h[277] = 0;
work.h[278] = 0;
work.h[279] = params.x_max_3[0];
work.h[280] = 0;
work.h[281] = 0;
work.h[282] = params.x_max_3[0];
work.h[283] = 0;
work.h[284] = 0;
work.h[285] = params.x_max_3[0];
work.h[286] = 0;
work.h[287] = 0;
work.h[288] = params.x_max_3[0];
work.h[289] = 0;
work.h[290] = 0;
work.h[291] = params.x_max_3[0];
work.h[292] = 0;
work.h[293] = 0;
work.h[294] = params.x_max_3[0];
work.h[295] = 0;
work.h[296] = 0;
work.h[297] = params.x_max_3[0];
work.h[298] = 0;
work.h[299] = 0;
work.h[300] = params.x_max_3[0];
work.h[301] = 0;
work.h[302] = 0;
work.h[303] = params.x_max_3[0];
work.h[304] = 0;
work.h[305] = 0;
work.h[306] = params.x_max_3[0];
work.h[307] = 0;
work.h[308] = 0;
work.h[309] = params.x_max_3[0];
work.h[310] = 0;
work.h[311] = 0;
}
void fillb(void) {
work.b[0] = params.Af[0]*params.x_0[0]+params.Af[3]*params.x_0[1];
work.b[1] = params.Af[1]*params.x_0[1]+params.Af[4]*params.x_0[2];
work.b[2] = params.Af[2]*params.x_0[2];
work.b[3] = 0;
work.b[4] = 0;
work.b[5] = 0;
work.b[6] = 0;
work.b[7] = 0;
work.b[8] = 0;
work.b[9] = 0;
work.b[10] = 0;
work.b[11] = 0;
work.b[12] = 0;
work.b[13] = 0;
work.b[14] = 0;
work.b[15] = 0;
work.b[16] = 0;
work.b[17] = 0;
work.b[18] = 0;
work.b[19] = 0;
work.b[20] = 0;
work.b[21] = 0;
work.b[22] = 0;
work.b[23] = 0;
work.b[24] = 0;
work.b[25] = 0;
work.b[26] = 0;
work.b[27] = 0;
work.b[28] = 0;
work.b[29] = 0;
work.b[30] = 0;
work.b[31] = 0;
work.b[32] = 0;
work.b[33] = 0;
work.b[34] = 0;
work.b[35] = 0;
work.b[36] = 0;
work.b[37] = 0;
work.b[38] = 0;
work.b[39] = 0;
work.b[40] = 0;
work.b[41] = 0;
work.b[42] = 0;
work.b[43] = 0;
work.b[44] = 0;
work.b[45] = 0;
work.b[46] = 0;
work.b[47] = 0;
work.b[48] = 0;
work.b[49] = 0;
work.b[50] = 0;
work.b[51] = 0;
work.b[52] = 0;
work.b[53] = 0;
work.b[54] = 0;
work.b[55] = 0;
work.b[56] = 0;
work.b[57] = 0;
work.b[58] = 0;
work.b[59] = 0;
work.b[60] = 0;
work.b[61] = 0;
work.b[62] = 0;
work.b[63] = 0;
work.b[64] = 0;
work.b[65] = 0;
work.b[66] = 0;
work.b[67] = 0;
work.b[68] = 0;
work.b[69] = 0;
work.b[70] = 0;
work.b[71] = 0;
work.b[72] = 0;
work.b[73] = 0;
work.b[74] = 0;
work.b[75] = 0;
work.b[76] = 0;
work.b[77] = 0;
}
void pre_ops(void) {
work.quad_600568381440[0] = params.x_ss_1[0]*params.Q[0]*params.x_ss_1[0]+params.x_ss_1[1]*params.Q[1]*params.x_ss_1[1]+params.x_ss_1[2]*params.Q[2]*params.x_ss_1[2];
work.quad_898851794944[0] = params.x_ss_2[0]*params.Q[0]*params.x_ss_2[0]+params.x_ss_2[1]*params.Q[1]*params.x_ss_2[1]+params.x_ss_2[2]*params.Q[2]*params.x_ss_2[2];
work.quad_88433618944[0] = params.x_ss_3[0]*params.Q[0]*params.x_ss_3[0]+params.x_ss_3[1]*params.Q[1]*params.x_ss_3[1]+params.x_ss_3[2]*params.Q[2]*params.x_ss_3[2];
work.quad_240204779520[0] = params.x_ss_4[0]*params.Q[0]*params.x_ss_4[0]+params.x_ss_4[1]*params.Q[1]*params.x_ss_4[1]+params.x_ss_4[2]*params.Q[2]*params.x_ss_4[2];
work.quad_635618762752[0] = params.x_ss_5[0]*params.Q[0]*params.x_ss_5[0]+params.x_ss_5[1]*params.Q[1]*params.x_ss_5[1]+params.x_ss_5[2]*params.Q[2]*params.x_ss_5[2];
work.quad_732753989632[0] = params.x_ss_6[0]*params.Q[0]*params.x_ss_6[0]+params.x_ss_6[1]*params.Q[1]*params.x_ss_6[1]+params.x_ss_6[2]*params.Q[2]*params.x_ss_6[2];
work.quad_427523055616[0] = params.x_ss_7[0]*params.Q[0]*params.x_ss_7[0]+params.x_ss_7[1]*params.Q[1]*params.x_ss_7[1]+params.x_ss_7[2]*params.Q[2]*params.x_ss_7[2];
work.quad_976046530560[0] = params.x_ss_8[0]*params.Q[0]*params.x_ss_8[0]+params.x_ss_8[1]*params.Q[1]*params.x_ss_8[1]+params.x_ss_8[2]*params.Q[2]*params.x_ss_8[2];
work.quad_688550678528[0] = params.x_ss_9[0]*params.Q[0]*params.x_ss_9[0]+params.x_ss_9[1]*params.Q[1]*params.x_ss_9[1]+params.x_ss_9[2]*params.Q[2]*params.x_ss_9[2];
work.quad_304816418816[0] = params.x_ss_10[0]*params.Q[0]*params.x_ss_10[0]+params.x_ss_10[1]*params.Q[1]*params.x_ss_10[1]+params.x_ss_10[2]*params.Q[2]*params.x_ss_10[2];
work.quad_819339411456[0] = params.x_ss_11[0]*params.Q[0]*params.x_ss_11[0]+params.x_ss_11[1]*params.Q[1]*params.x_ss_11[1]+params.x_ss_11[2]*params.Q[2]*params.x_ss_11[2];
work.quad_101800079360[0] = params.x_ss_12[0]*params.Q[0]*params.x_ss_12[0]+params.x_ss_12[1]*params.Q[1]*params.x_ss_12[1]+params.x_ss_12[2]*params.Q[2]*params.x_ss_12[2];
work.quad_976903761920[0] = params.x_ss_13[0]*params.Q[0]*params.x_ss_13[0]+params.x_ss_13[1]*params.Q[1]*params.x_ss_13[1]+params.x_ss_13[2]*params.Q[2]*params.x_ss_13[2];
work.quad_141299838976[0] = params.x_ss_14[0]*params.Q[0]*params.x_ss_14[0]+params.x_ss_14[1]*params.Q[1]*params.x_ss_14[1]+params.x_ss_14[2]*params.Q[2]*params.x_ss_14[2];
work.quad_343404097536[0] = params.x_ss_15[0]*params.Q[0]*params.x_ss_15[0]+params.x_ss_15[1]*params.Q[1]*params.x_ss_15[1]+params.x_ss_15[2]*params.Q[2]*params.x_ss_15[2];
work.quad_815806124032[0] = params.x_ss_16[0]*params.Q[0]*params.x_ss_16[0]+params.x_ss_16[1]*params.Q[1]*params.x_ss_16[1]+params.x_ss_16[2]*params.Q[2]*params.x_ss_16[2];
work.quad_997002137600[0] = params.x_ss_17[0]*params.Q[0]*params.x_ss_17[0]+params.x_ss_17[1]*params.Q[1]*params.x_ss_17[1]+params.x_ss_17[2]*params.Q[2]*params.x_ss_17[2];
work.quad_141630619648[0] = params.x_ss_18[0]*params.Q[0]*params.x_ss_18[0]+params.x_ss_18[1]*params.Q[1]*params.x_ss_18[1]+params.x_ss_18[2]*params.Q[2]*params.x_ss_18[2];
work.quad_835263414272[0] = params.x_ss_19[0]*params.Q[0]*params.x_ss_19[0]+params.x_ss_19[1]*params.Q[1]*params.x_ss_19[1]+params.x_ss_19[2]*params.Q[2]*params.x_ss_19[2];
work.quad_962643562496[0] = params.x_ss_20[0]*params.Q[0]*params.x_ss_20[0]+params.x_ss_20[1]*params.Q[1]*params.x_ss_20[1]+params.x_ss_20[2]*params.Q[2]*params.x_ss_20[2];
work.quad_928463360000[0] = params.x_ss_21[0]*params.Q[0]*params.x_ss_21[0]+params.x_ss_21[1]*params.Q[1]*params.x_ss_21[1]+params.x_ss_21[2]*params.Q[2]*params.x_ss_21[2];
work.quad_380101586944[0] = params.x_ss_22[0]*params.Q[0]*params.x_ss_22[0]+params.x_ss_22[1]*params.Q[1]*params.x_ss_22[1]+params.x_ss_22[2]*params.Q[2]*params.x_ss_22[2];
work.quad_150659375104[0] = params.x_ss_23[0]*params.Q[0]*params.x_ss_23[0]+params.x_ss_23[1]*params.Q[1]*params.x_ss_23[1]+params.x_ss_23[2]*params.Q[2]*params.x_ss_23[2];
work.quad_392524365824[0] = params.x_ss_24[0]*params.Q[0]*params.x_ss_24[0]+params.x_ss_24[1]*params.Q[1]*params.x_ss_24[1]+params.x_ss_24[2]*params.Q[2]*params.x_ss_24[2];
work.quad_653656117248[0] = params.x_ss_25[0]*params.Q[0]*params.x_ss_25[0]+params.x_ss_25[1]*params.Q[1]*params.x_ss_25[1]+params.x_ss_25[2]*params.Q[2]*params.x_ss_25[2];
work.quad_758104227840[0] = params.x_ss_26[0]*params.Q_last[0]*params.x_ss_26[0]+params.x_ss_26[1]*params.Q_last[1]*params.x_ss_26[1]+params.x_ss_26[2]*params.Q_last[2]*params.x_ss_26[2];
}
|
larics/uav_ros_control
|
src/control/cvxgen/solver.c
|
<reponame>larics/uav_ros_control
/* Produced by CVXGEN, 2021-03-12 04:35:31 -0500. */
/* CVXGEN is Copyright (C) 2006-2017 <NAME>, <EMAIL>. */
/* The code in this file is Copyright (C) 2006-2017 <NAME>. */
/* CVXGEN, or solvers produced by CVXGEN, cannot be used for commercial */
/* applications without prior written permission from <NAME>. */
/* Filename: solver.c. */
/* Description: Main solver file. */
#include "solver.h"
double eval_gap(void) {
int i;
double gap;
gap = 0;
for (i = 0; i < 312; i++)
gap += work.z[i]*work.s[i];
return gap;
}
void set_defaults(void) {
settings.resid_tol = 1e-6;
settings.eps = 1e-4;
settings.max_iters = 25;
settings.refine_steps = 1;
settings.s_init = 1;
settings.z_init = 1;
settings.debug = 0;
settings.verbose = 1;
settings.verbose_refinement = 0;
settings.better_start = 1;
settings.kkt_reg = 1e-7;
}
void setup_pointers(void) {
work.y = work.x + 208;
work.s = work.x + 286;
work.z = work.x + 598;
vars.u_0 = work.x + 104;
vars.u_1 = work.x + 105;
vars.u_2 = work.x + 106;
vars.u_3 = work.x + 107;
vars.u_4 = work.x + 108;
vars.u_5 = work.x + 109;
vars.u_6 = work.x + 110;
vars.u_7 = work.x + 111;
vars.u_8 = work.x + 112;
vars.u_9 = work.x + 113;
vars.u_10 = work.x + 114;
vars.u_11 = work.x + 115;
vars.u_12 = work.x + 116;
vars.u_13 = work.x + 117;
vars.u_14 = work.x + 118;
vars.u_15 = work.x + 119;
vars.u_16 = work.x + 120;
vars.u_17 = work.x + 121;
vars.u_18 = work.x + 122;
vars.u_19 = work.x + 123;
vars.u_20 = work.x + 124;
vars.u_21 = work.x + 125;
vars.u_22 = work.x + 126;
vars.u_23 = work.x + 127;
vars.u_24 = work.x + 128;
vars.u_25 = work.x + 129;
vars.x_1 = work.x + 130;
vars.x_2 = work.x + 133;
vars.x_3 = work.x + 136;
vars.x_4 = work.x + 139;
vars.x_5 = work.x + 142;
vars.x_6 = work.x + 145;
vars.x_7 = work.x + 148;
vars.x_8 = work.x + 151;
vars.x_9 = work.x + 154;
vars.x_10 = work.x + 157;
vars.x_11 = work.x + 160;
vars.x_12 = work.x + 163;
vars.x_13 = work.x + 166;
vars.x_14 = work.x + 169;
vars.x_15 = work.x + 172;
vars.x_16 = work.x + 175;
vars.x_17 = work.x + 178;
vars.x_18 = work.x + 181;
vars.x_19 = work.x + 184;
vars.x_20 = work.x + 187;
vars.x_21 = work.x + 190;
vars.x_22 = work.x + 193;
vars.x_23 = work.x + 196;
vars.x_24 = work.x + 199;
vars.x_25 = work.x + 202;
vars.x_26 = work.x + 205;
}
void setup_indexed_params(void) {
/* In CVXGEN, you can say */
/* parameters */
/* A[i] (5,3), i=1..4 */
/* end */
/* This function sets up A[2] to be a pointer to A_2, which is a length-15 */
/* vector of doubles. */
/* If you access parameters that you haven't defined in CVXGEN, the result */
/* is undefined. */
params.x_ss[1] = params.x_ss_1;
params.x_ss[2] = params.x_ss_2;
params.x_ss[3] = params.x_ss_3;
params.x_ss[4] = params.x_ss_4;
params.x_ss[5] = params.x_ss_5;
params.x_ss[6] = params.x_ss_6;
params.x_ss[7] = params.x_ss_7;
params.x_ss[8] = params.x_ss_8;
params.x_ss[9] = params.x_ss_9;
params.x_ss[10] = params.x_ss_10;
params.x_ss[11] = params.x_ss_11;
params.x_ss[12] = params.x_ss_12;
params.x_ss[13] = params.x_ss_13;
params.x_ss[14] = params.x_ss_14;
params.x_ss[15] = params.x_ss_15;
params.x_ss[16] = params.x_ss_16;
params.x_ss[17] = params.x_ss_17;
params.x_ss[18] = params.x_ss_18;
params.x_ss[19] = params.x_ss_19;
params.x_ss[20] = params.x_ss_20;
params.x_ss[21] = params.x_ss_21;
params.x_ss[22] = params.x_ss_22;
params.x_ss[23] = params.x_ss_23;
params.x_ss[24] = params.x_ss_24;
params.x_ss[25] = params.x_ss_25;
params.x_ss[26] = params.x_ss_26;
params.x[0] = params.x_0;
}
void setup_indexed_optvars(void) {
/* In CVXGEN, you can say */
/* variables */
/* x[i] (5), i=2..4 */
/* end */
/* This function sets up x[3] to be a pointer to x_3, which is a length-5 */
/* vector of doubles. */
/* If you access variables that you haven't defined in CVXGEN, the result */
/* is undefined. */
vars.x[1] = vars.x_1;
vars.x[2] = vars.x_2;
vars.x[3] = vars.x_3;
vars.x[4] = vars.x_4;
vars.x[5] = vars.x_5;
vars.x[6] = vars.x_6;
vars.x[7] = vars.x_7;
vars.x[8] = vars.x_8;
vars.x[9] = vars.x_9;
vars.x[10] = vars.x_10;
vars.x[11] = vars.x_11;
vars.x[12] = vars.x_12;
vars.x[13] = vars.x_13;
vars.x[14] = vars.x_14;
vars.x[15] = vars.x_15;
vars.x[16] = vars.x_16;
vars.x[17] = vars.x_17;
vars.x[18] = vars.x_18;
vars.x[19] = vars.x_19;
vars.x[20] = vars.x_20;
vars.x[21] = vars.x_21;
vars.x[22] = vars.x_22;
vars.x[23] = vars.x_23;
vars.x[24] = vars.x_24;
vars.x[25] = vars.x_25;
vars.x[26] = vars.x_26;
vars.u[0] = vars.u_0;
vars.u[1] = vars.u_1;
vars.u[2] = vars.u_2;
vars.u[3] = vars.u_3;
vars.u[4] = vars.u_4;
vars.u[5] = vars.u_5;
vars.u[6] = vars.u_6;
vars.u[7] = vars.u_7;
vars.u[8] = vars.u_8;
vars.u[9] = vars.u_9;
vars.u[10] = vars.u_10;
vars.u[11] = vars.u_11;
vars.u[12] = vars.u_12;
vars.u[13] = vars.u_13;
vars.u[14] = vars.u_14;
vars.u[15] = vars.u_15;
vars.u[16] = vars.u_16;
vars.u[17] = vars.u_17;
vars.u[18] = vars.u_18;
vars.u[19] = vars.u_19;
vars.u[20] = vars.u_20;
vars.u[21] = vars.u_21;
vars.u[22] = vars.u_22;
vars.u[23] = vars.u_23;
vars.u[24] = vars.u_24;
vars.u[25] = vars.u_25;
}
void setup_indexing(void) {
setup_pointers();
setup_indexed_params();
setup_indexed_optvars();
}
void set_start(void) {
int i;
for (i = 0; i < 208; i++)
work.x[i] = 0;
for (i = 0; i < 78; i++)
work.y[i] = 0;
for (i = 0; i < 312; i++)
work.s[i] = (work.h[i] > 0) ? work.h[i] : settings.s_init;
for (i = 0; i < 312; i++)
work.z[i] = settings.z_init;
}
double eval_objv(void) {
int i;
double objv;
/* Borrow space in work.rhs. */
multbyP(work.rhs, work.x);
objv = 0;
for (i = 0; i < 208; i++)
objv += work.x[i]*work.rhs[i];
objv *= 0.5;
for (i = 0; i < 208; i++)
objv += work.q[i]*work.x[i];
objv += work.quad_600568381440[0]+work.quad_898851794944[0]+work.quad_88433618944[0]+work.quad_240204779520[0]+work.quad_635618762752[0]+work.quad_732753989632[0]+work.quad_427523055616[0]+work.quad_976046530560[0]+work.quad_688550678528[0]+work.quad_304816418816[0]+work.quad_819339411456[0]+work.quad_101800079360[0]+work.quad_976903761920[0]+work.quad_141299838976[0]+work.quad_343404097536[0]+work.quad_815806124032[0]+work.quad_997002137600[0]+work.quad_141630619648[0]+work.quad_835263414272[0]+work.quad_962643562496[0]+work.quad_928463360000[0]+work.quad_380101586944[0]+work.quad_150659375104[0]+work.quad_392524365824[0]+work.quad_653656117248[0]+work.quad_758104227840[0];
return objv;
}
void fillrhs_aff(void) {
int i;
double *r1, *r2, *r3, *r4;
r1 = work.rhs;
r2 = work.rhs + 208;
r3 = work.rhs + 520;
r4 = work.rhs + 832;
/* r1 = -A^Ty - G^Tz - Px - q. */
multbymAT(r1, work.y);
multbymGT(work.buffer, work.z);
for (i = 0; i < 208; i++)
r1[i] += work.buffer[i];
multbyP(work.buffer, work.x);
for (i = 0; i < 208; i++)
r1[i] -= work.buffer[i] + work.q[i];
/* r2 = -z. */
for (i = 0; i < 312; i++)
r2[i] = -work.z[i];
/* r3 = -Gx - s + h. */
multbymG(r3, work.x);
for (i = 0; i < 312; i++)
r3[i] += -work.s[i] + work.h[i];
/* r4 = -Ax + b. */
multbymA(r4, work.x);
for (i = 0; i < 78; i++)
r4[i] += work.b[i];
}
void fillrhs_cc(void) {
int i;
double *r2;
double *ds_aff, *dz_aff;
double mu;
double alpha;
double sigma;
double smu;
double minval;
r2 = work.rhs + 208;
ds_aff = work.lhs_aff + 208;
dz_aff = work.lhs_aff + 520;
mu = 0;
for (i = 0; i < 312; i++)
mu += work.s[i]*work.z[i];
/* Don't finish calculating mu quite yet. */
/* Find min(min(ds./s), min(dz./z)). */
minval = 0;
for (i = 0; i < 312; i++)
if (ds_aff[i] < minval*work.s[i])
minval = ds_aff[i]/work.s[i];
for (i = 0; i < 312; i++)
if (dz_aff[i] < minval*work.z[i])
minval = dz_aff[i]/work.z[i];
/* Find alpha. */
if (-1 < minval)
alpha = 1;
else
alpha = -1/minval;
sigma = 0;
for (i = 0; i < 312; i++)
sigma += (work.s[i] + alpha*ds_aff[i])*
(work.z[i] + alpha*dz_aff[i]);
sigma /= mu;
sigma = sigma*sigma*sigma;
/* Finish calculating mu now. */
mu *= 0.003205128205128205;
smu = sigma*mu;
/* Fill-in the rhs. */
for (i = 0; i < 208; i++)
work.rhs[i] = 0;
for (i = 520; i < 910; i++)
work.rhs[i] = 0;
for (i = 0; i < 312; i++)
r2[i] = work.s_inv[i]*(smu - ds_aff[i]*dz_aff[i]);
}
void refine(double *target, double *var) {
int i, j;
double *residual = work.buffer;
double norm2;
double *new_var = work.buffer2;
for (j = 0; j < settings.refine_steps; j++) {
norm2 = 0;
matrix_multiply(residual, var);
for (i = 0; i < 910; i++) {
residual[i] = residual[i] - target[i];
norm2 += residual[i]*residual[i];
}
#ifndef ZERO_LIBRARY_MODE
if (settings.verbose_refinement) {
if (j == 0)
printf("Initial residual before refinement has norm squared %.6g.\n", norm2);
else
printf("After refinement we get squared norm %.6g.\n", norm2);
}
#endif
/* Solve to find new_var = KKT \ (target - A*var). */
ldl_solve(residual, new_var);
/* Update var += new_var, or var += KKT \ (target - A*var). */
for (i = 0; i < 910; i++) {
var[i] -= new_var[i];
}
}
#ifndef ZERO_LIBRARY_MODE
if (settings.verbose_refinement) {
/* Check the residual once more, but only if we're reporting it, since */
/* it's expensive. */
norm2 = 0;
matrix_multiply(residual, var);
for (i = 0; i < 910; i++) {
residual[i] = residual[i] - target[i];
norm2 += residual[i]*residual[i];
}
if (j == 0)
printf("Initial residual before refinement has norm squared %.6g.\n", norm2);
else
printf("After refinement we get squared norm %.6g.\n", norm2);
}
#endif
}
double calc_ineq_resid_squared(void) {
/* Calculates the norm ||-Gx - s + h||. */
double norm2_squared;
int i;
/* Find -Gx. */
multbymG(work.buffer, work.x);
/* Add -s + h. */
for (i = 0; i < 312; i++)
work.buffer[i] += -work.s[i] + work.h[i];
/* Now find the squared norm. */
norm2_squared = 0;
for (i = 0; i < 312; i++)
norm2_squared += work.buffer[i]*work.buffer[i];
return norm2_squared;
}
double calc_eq_resid_squared(void) {
/* Calculates the norm ||-Ax + b||. */
double norm2_squared;
int i;
/* Find -Ax. */
multbymA(work.buffer, work.x);
/* Add +b. */
for (i = 0; i < 78; i++)
work.buffer[i] += work.b[i];
/* Now find the squared norm. */
norm2_squared = 0;
for (i = 0; i < 78; i++)
norm2_squared += work.buffer[i]*work.buffer[i];
return norm2_squared;
}
void better_start(void) {
/* Calculates a better starting point, using a similar approach to CVXOPT. */
/* Not yet speed optimized. */
int i;
double *x, *s, *z, *y;
double alpha;
work.block_33[0] = -1;
/* Make sure sinvz is 1 to make hijacked KKT system ok. */
for (i = 0; i < 312; i++)
work.s_inv_z[i] = 1;
fill_KKT();
ldl_factor();
fillrhs_start();
/* Borrow work.lhs_aff for the solution. */
ldl_solve(work.rhs, work.lhs_aff);
/* Don't do any refinement for now. Precision doesn't matter too much. */
x = work.lhs_aff;
s = work.lhs_aff + 208;
z = work.lhs_aff + 520;
y = work.lhs_aff + 832;
/* Just set x and y as is. */
for (i = 0; i < 208; i++)
work.x[i] = x[i];
for (i = 0; i < 78; i++)
work.y[i] = y[i];
/* Now complete the initialization. Start with s. */
/* Must have alpha > max(z). */
alpha = -1e99;
for (i = 0; i < 312; i++)
if (alpha < z[i])
alpha = z[i];
if (alpha < 0) {
for (i = 0; i < 312; i++)
work.s[i] = -z[i];
} else {
alpha += 1;
for (i = 0; i < 312; i++)
work.s[i] = -z[i] + alpha;
}
/* Now initialize z. */
/* Now must have alpha > max(-z). */
alpha = -1e99;
for (i = 0; i < 312; i++)
if (alpha < -z[i])
alpha = -z[i];
if (alpha < 0) {
for (i = 0; i < 312; i++)
work.z[i] = z[i];
} else {
alpha += 1;
for (i = 0; i < 312; i++)
work.z[i] = z[i] + alpha;
}
}
void fillrhs_start(void) {
/* Fill rhs with (-q, 0, h, b). */
int i;
double *r1, *r2, *r3, *r4;
r1 = work.rhs;
r2 = work.rhs + 208;
r3 = work.rhs + 520;
r4 = work.rhs + 832;
for (i = 0; i < 208; i++)
r1[i] = -work.q[i];
for (i = 0; i < 312; i++)
r2[i] = 0;
for (i = 0; i < 312; i++)
r3[i] = work.h[i];
for (i = 0; i < 78; i++)
r4[i] = work.b[i];
}
long solve(void) {
int i;
int iter;
double *dx, *ds, *dy, *dz;
double minval;
double alpha;
work.converged = 0;
setup_pointers();
pre_ops();
#ifndef ZERO_LIBRARY_MODE
if (settings.verbose)
printf("iter objv gap |Ax-b| |Gx+s-h| step\n");
#endif
fillq();
fillh();
fillb();
if (settings.better_start)
better_start();
else
set_start();
for (iter = 0; iter < settings.max_iters; iter++) {
for (i = 0; i < 312; i++) {
work.s_inv[i] = 1.0 / work.s[i];
work.s_inv_z[i] = work.s_inv[i]*work.z[i];
}
work.block_33[0] = 0;
fill_KKT();
ldl_factor();
/* Affine scaling directions. */
fillrhs_aff();
ldl_solve(work.rhs, work.lhs_aff);
refine(work.rhs, work.lhs_aff);
/* Centering plus corrector directions. */
fillrhs_cc();
ldl_solve(work.rhs, work.lhs_cc);
refine(work.rhs, work.lhs_cc);
/* Add the two together and store in aff. */
for (i = 0; i < 910; i++)
work.lhs_aff[i] += work.lhs_cc[i];
/* Rename aff to reflect its new meaning. */
dx = work.lhs_aff;
ds = work.lhs_aff + 208;
dz = work.lhs_aff + 520;
dy = work.lhs_aff + 832;
/* Find min(min(ds./s), min(dz./z)). */
minval = 0;
for (i = 0; i < 312; i++)
if (ds[i] < minval*work.s[i])
minval = ds[i]/work.s[i];
for (i = 0; i < 312; i++)
if (dz[i] < minval*work.z[i])
minval = dz[i]/work.z[i];
/* Find alpha. */
if (-0.99 < minval)
alpha = 1;
else
alpha = -0.99/minval;
/* Update the primal and dual variables. */
for (i = 0; i < 208; i++)
work.x[i] += alpha*dx[i];
for (i = 0; i < 312; i++)
work.s[i] += alpha*ds[i];
for (i = 0; i < 312; i++)
work.z[i] += alpha*dz[i];
for (i = 0; i < 78; i++)
work.y[i] += alpha*dy[i];
work.gap = eval_gap();
work.eq_resid_squared = calc_eq_resid_squared();
work.ineq_resid_squared = calc_ineq_resid_squared();
#ifndef ZERO_LIBRARY_MODE
if (settings.verbose) {
work.optval = eval_objv();
printf("%3d %10.3e %9.2e %9.2e %9.2e % 6.4f\n",
iter+1, work.optval, work.gap, sqrt(work.eq_resid_squared),
sqrt(work.ineq_resid_squared), alpha);
}
#endif
/* Test termination conditions. Requires optimality, and satisfied */
/* constraints. */
if ( (work.gap < settings.eps)
&& (work.eq_resid_squared <= settings.resid_tol*settings.resid_tol)
&& (work.ineq_resid_squared <= settings.resid_tol*settings.resid_tol)
) {
work.converged = 1;
work.optval = eval_objv();
return iter+1;
}
}
return iter;
}
|
zsx/renc-rs
|
renc-sys/wrapper.h
|
<filename>renc-sys/wrapper.h
#include "renc/shim/valist.c"
//#include "renc/include/rebol.h"
|
zsx/renc-rs
|
renc-sys/test/rebol.c
|
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "rebol.h"
int main ()
{
RL_rebStartup();
REBVAL *one = RL_rebInteger(1);
#ifdef GOOD
assert(1 == rebUnboxInteger(one));
#else
assert(1 == RL_rebUnboxInteger0(one));
#endif
rebRelease(one);
RL_rebShutdown(1);
return 0;
}
|
xzrunner/ce
|
include/archgraph/op/ShapeO.h
|
#pragma once
#include "archgraph/Operation.h"
#include <SM_Vector.h>
namespace archgraph
{
namespace op
{
class ShapeO : public Operation
{
public:
enum OutputID
{
OUT_SHAPE = 0,
OUT_REMAINDER,
};
public:
ShapeO()
{
m_imports = {
{{ OpVarType::Any, "in" }},
};
m_exports = {
{{ OpVarType::Any, "shape" }},
{{ OpVarType::Any, "remainder" }},
};
}
virtual void Execute(const std::vector<GeoPtr>& in, std::vector<GeoPtr>& out,
const EvalContext& ctx) override;
RTTR_ENABLE(Operation)
#define PARM_FILEPATH "archgraph/op/ShapeO.parm.h"
#include <dag/node_parms_gen.h>
#undef PARM_FILEPATH
}; // ShapeO
}
}
|
xzrunner/ce
|
include/archgraph/op/Center.h
|
<filename>include/archgraph/op/Center.h
#pragma once
#include "archgraph/Operation.h"
#include <SM_Vector.h>
namespace archgraph
{
namespace op
{
class Center : public Operation
{
public:
Center()
{
m_imports = {
{{ OpVarType::Any, "in" }},
};
m_exports = {
{{ OpVarType::Any, "out" }},
};
}
virtual void Execute(const std::vector<GeoPtr>& in, std::vector<GeoPtr>& out,
const EvalContext& ctx) override;
RTTR_ENABLE(Operation)
}; // Center
}
}
|
xzrunner/ce
|
include/archgraph/EvalOp.h
|
#pragma once
#include "archgraph/typedef.h"
#include "archgraph/Operation.h"
#include "archgraph/EvalContext.h"
namespace ur { class Device; }
namespace archgraph
{
class EvalRule;
class EvalOp
{
public:
EvalOp(std::function<void(const ur::Device&, const std::vector<GeoPtr>&, void*)> execute_cb = nullptr);
// update operations
void AddOp(const OpPtr& op, void* ud = nullptr);
void RemoveOp(const OpPtr& op);
void ClearAllOps();
// update op prop
void PropChanged(const OpPtr& op);
// update op conn
void Connect(const Operation::PortAddr& from, const Operation::PortAddr& to);
void Disconnect(const Operation::PortAddr& from, const Operation::PortAddr& to);
void RebuildConnections(const std::vector<std::pair<Operation::PortAddr, Operation::PortAddr>>& conns);
std::map<OpPtr, std::vector<GeoPtr>> Eval(const ur::Device& dev, const EvalContext& ctx) const;
std::shared_ptr<EvalRule> ToRule(const EvalContext& ctx) const;
void MakeDirty(bool all_ops_dirty = true);
void Rename(const std::string& from, const std::string& to);
private:
static void SetTreeDirty(const OpPtr& root);
static bool HasOpConns(const OpPtr& op);
private:
std::function<void(const ur::Device&, const std::vector<GeoPtr>&, void*)> m_execute_cb = nullptr;
std::map<std::string, std::pair<OpPtr, void*>> m_ops_map;
bool m_dirty = false;
size_t m_next_id = 0;
}; // EvalOp
}
|
xzrunner/ce
|
include/archgraph/Operation.h
|
#pragma once
#include "archgraph/typedef.h"
#include "archgraph/OpVarType.h"
#include "archgraph/Rule.h"
#include <dag/Node.h>
#include <cga/typedef.h>
namespace archgraph
{
class Geometry;
class EvalContext;
class Operation : public dag::Node<OpVarType>
{
public:
Operation();
virtual void Execute(const std::vector<GeoPtr>& in, std::vector<GeoPtr>& out,
const EvalContext& ctx) = 0;
virtual void AddInputPorts(size_t num) {}
virtual void Setup(const std::vector<cga::ExprNodePtr>& parms,
const Rule::CompoundSel& selectors, const EvalContext& ctx) {}
bool IsPortChanged() const { return m_port_changed; }
void SetPortChanged(bool changed) { m_port_changed = changed; }
auto& GetExprsMap() const { return m_exprs_map; }
protected:
std::map<std::string, std::string> m_exprs_map;
private:
bool m_port_changed = false;
RTTR_ENABLE(dag::Node<OpVarType>)
}; // Operation
}
|
xzrunner/ce
|
include/archgraph/op/PrimQuad.parm.h
|
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(Width, float, width, m_width, (1.0f))
PARAM_INFO(Length, float, length, m_length, (1.0f))
|
xzrunner/ce
|
include/archgraph/op/Switch.h
|
<reponame>xzrunner/ce
#pragma once
#include "archgraph/Operation.h"
#include <SM_Vector.h>
namespace archgraph
{
namespace op
{
class Switch : public Operation
{
public:
Switch()
{
m_imports = {
{{ OpVarType::Any, "in" }},
};
m_exports = {
{{ OpVarType::Any, "else" }},
};
}
virtual void OnParmChanged(const std::string& parm_name) override;
virtual void Execute(const std::vector<GeoPtr>& in, std::vector<GeoPtr>& out,
const EvalContext& ctx) override;
virtual void Setup(const std::vector<cga::ExprNodePtr>& parms,
const Rule::CompoundSel& selectors, const EvalContext& ctx) override;
private:
void SetupExports();
private:
std::vector<cga::ExprNodePtr> m_case_exprs;
RTTR_ENABLE(Operation)
#define PARM_FILEPATH "archgraph/op/Switch.parm.h"
#include <dag/node_parms_gen.h>
#undef PARM_FILEPATH
}; // Switch
}
}
|
xzrunner/ce
|
include/archgraph/op/Offset.h
|
#pragma once
#include "archgraph/Operation.h"
#include <SM_Vector.h>
namespace archgraph
{
namespace op
{
class Offset : public Operation
{
public:
enum class Selector
{
All,
Inside,
Border,
};
public:
Offset()
{
m_imports = {
{{ OpVarType::Any, "in" }},
};
m_exports = {
{{ OpVarType::Any, "out" }},
};
}
virtual void Execute(const std::vector<GeoPtr>& in, std::vector<GeoPtr>& out,
const EvalContext& ctx) override;
virtual void Setup(const std::vector<cga::ExprNodePtr>& parms,
const Rule::CompoundSel& selectors, const EvalContext& ctx) override;
RTTR_ENABLE(Operation)
#define PARM_FILEPATH "archgraph/op/Offset.parm.h"
#include <dag/node_parms_gen.h>
#undef PARM_FILEPATH
}; // Offset
}
}
|
xzrunner/ce
|
include/archgraph/op_regist_cfg.h
|
#ifndef EXE_FILEPATH
#error "You must define EXE_FILEPATH macro before include this file"
#endif
// creation
#define PARM_OP_CLASS Extrude
#define PARM_OP_NAME extrude
#include EXE_FILEPATH
#define PARM_OP_CLASS Insert
#define PARM_OP_NAME i
#include EXE_FILEPATH
#define PARM_OP_CLASS PrimCube
#define PARM_OP_NAME prim_cube
#include EXE_FILEPATH
#define PARM_OP_CLASS PrimQuad
#define PARM_OP_NAME prim_quad
#include EXE_FILEPATH
#define PARM_OP_CLASS PrimPoly
#define PARM_OP_NAME prim_poly
#include EXE_FILEPATH
// subdivision
#define PARM_OP_CLASS Comp
#define PARM_OP_NAME comp
#include EXE_FILEPATH
#define PARM_OP_CLASS Offset
#define PARM_OP_NAME offset
#include EXE_FILEPATH
#define PARM_OP_CLASS ShapeO
#define PARM_OP_NAME shapeo
#include EXE_FILEPATH
#define PARM_OP_CLASS Split
#define PARM_OP_NAME split
#include EXE_FILEPATH
// transformations
#define PARM_OP_CLASS Center
#define PARM_OP_NAME center
#include EXE_FILEPATH
#define PARM_OP_CLASS Scale
#define PARM_OP_NAME s
#include EXE_FILEPATH
#define PARM_OP_CLASS TransScope
#define PARM_OP_NAME t
#include EXE_FILEPATH
// scope
#define PARM_OP_CLASS AlignScopeToGeo
#define PARM_OP_NAME alignScopeToGeometry
#include EXE_FILEPATH
// flow control
#define PARM_OP_CLASS NIL
#define PARM_OP_NAME NIL
#include EXE_FILEPATH
#define PARM_OP_CLASS Switch
#define PARM_OP_NAME switch
#include EXE_FILEPATH
// attributes
#define PARM_OP_CLASS Color
#define PARM_OP_NAME color
#include EXE_FILEPATH
#define PARM_OP_CLASS Set
#define PARM_OP_NAME set
#include EXE_FILEPATH
|
xzrunner/ce
|
test/utility.h
|
<filename>test/utility.h
#pragma once
#include <SM_Vector.h>
#include <archgraph/typedef.h>
#include <map>
#include <vector>
namespace test
{
void init();
void check_aabb(const archgraph::Geometry& geo, const sm::vec3& min, const sm::vec3& max);
void check_aabb_holes(const archgraph::Geometry& geo, const sm::vec3& min, const sm::vec3& max);
void check_points_num(const archgraph::Geometry& geo, size_t num);
void check_faces_num(const archgraph::Geometry& geo, size_t num);
void check_single_face_norm(const archgraph::Geometry& geo, const sm::vec3& norm);
void check_single_face_area(const archgraph::Geometry& geo, float area);
archgraph::GeoPtr query_geo(const std::map<archgraph::OpPtr, std::vector<archgraph::GeoPtr>>& geos,
const archgraph::OpPtr& node, size_t out_id = 0);
void check_color(const archgraph::Geometry& geo, const sm::vec3& col);
}
|
xzrunner/ce
|
include/archgraph/EvalHelper.h
|
#pragma once
#include "archgraph/VarType.h"
#include "archgraph/typedef.h"
#include <cga/typedef.h>
#include <rttr/type.h>
namespace archgraph
{
struct RelativeFloat;
class EvalContext;
class EvalHelper
{
public:
static bool SetPropVal(rttr::property prop, rttr::instance obj,
const VarPtr& val);
static VarType ResolveSizeVal(const cga::ExprNodePtr& expr,
const EvalContext& ctx, RelativeFloat& out_flt, std::string& out_str);
}; // EvalHelper
}
|
xzrunner/ce
|
include/archgraph/ArchGraph.h
|
<filename>include/archgraph/ArchGraph.h<gh_stars>0
#pragma once
#include <cu/cu_macro.h>
#include <memory>
namespace cga { class StringPool; }
namespace archgraph
{
class ArchGraph
{
public:
auto GetStringPool() const { return m_str_pool; }
private:
std::shared_ptr<cga::StringPool> m_str_pool = nullptr;
CU_SINGLETON_DECLARATION(ArchGraph)
}; // ArchGraph
}
|
xzrunner/ce
|
include/archgraph/op/PrimCube.parm.h
|
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(Width, float, width, m_width, (1.0f))
PARAM_INFO(Height, float, height, m_height, (1.0f))
PARAM_INFO(Depth, float, depth, m_depth, (1.0f))
|
xzrunner/ce
|
include/archgraph/op/Set.h
|
<reponame>xzrunner/ce<filename>include/archgraph/op/Set.h
#pragma once
#include "archgraph/Operation.h"
namespace archgraph
{
namespace op
{
class Set : public Operation
{
public:
Set()
{
m_imports = {
{{ OpVarType::Any, "in" }},
};
m_exports = {
{{ OpVarType::Any, "out" }},
};
}
virtual void OnParmChanged(const std::string& parm_name) override;
virtual void Execute(const std::vector<GeoPtr>& in, std::vector<GeoPtr>& out,
const EvalContext& ctx) override;
virtual void Setup(const std::vector<cga::ExprNodePtr>& parms,
const Rule::CompoundSel& selectors, const EvalContext& ctx) override;
private:
cga::ExprNodePtr m_val_expr = nullptr;
RTTR_ENABLE(Operation)
#define PARM_FILEPATH "archgraph/op/Set.parm.h"
#include <dag/node_parms_gen.h>
#undef PARM_FILEPATH
}; // Set
}
}
|
xzrunner/ce
|
include/archgraph/op/Set.parm.h
|
<gh_stars>0
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(Attribute, std::string, attribute, m_attr, ())
PARAM_INFO(Value, std::string, value, m_value, ())
|
xzrunner/ce
|
include/archgraph/EvalRule.h
|
<gh_stars>0
#pragma once
#include "archgraph/typedef.h"
#include "archgraph/Rule.h"
#include "archgraph/EvalContext.h"
#include <cga/typedef.h>
#include <map>
#include <memory>
#include <vector>
#include <sstream>
namespace archgraph
{
class EvalRule
{
public:
EvalRule() {}
void AddRule(const RulePtr& rule);
RulePtr QueryRule(const std::string& name) const;
void OnLoadFinished(const EvalContext& ctx);
std::vector<GeoPtr> Eval(const std::vector<GeoPtr>& geos,
const EvalContext& ctx);
void SetFilepath(const std::string& filepath) { m_filepath = filepath; }
void Clear();
auto& GetConsole() const { return m_console; }
private:
void DeduceOps(const EvalContext& ctx);
void DeduceOps(const EvalContext& ctx, const Rule::SelPtr& sel);
std::vector<GeoPtr> Eval(const std::vector<GeoPtr>& geos,
const std::vector<Rule::OpPtr>& ops, const EvalContext& ctx);
std::vector<GeoPtr> Eval(const std::vector<GeoPtr>& geos,
const Rule::CompoundSel& sel, const EvalContext& ctx);
void ResolveParmsExpr(Operation& op, const EvalContext& ctx) const;
private:
class TopologicalSorting
{
public:
TopologicalSorting(const std::map<std::string, RulePtr>& rules);
std::vector<RulePtr> Sort();
private:
void PrepareOp(const Rule::OpPtr& op, int rule_idx);
void PrepareSel(const Rule::SelPtr& sel, int rule_idx);
void AddRuleDepend(const RulePtr& rule, int rule_idx);
private:
std::vector<RulePtr> m_rules;
std::vector<int> m_in_deg;
std::vector<std::vector<int>> m_out_ops;
}; // TopologicalSorting
private:
std::string m_filepath;
std::map<std::string, RulePtr> m_rules;
mutable std::vector<RulePtr> m_rules_sorted;
mutable std::stringstream m_console;
}; // EvalRule
}
|
xzrunner/ce
|
include/archgraph/Geometry.h
|
<filename>include/archgraph/Geometry.h<gh_stars>0
#pragma once
#include <SM_Vector.h>
#include <polymesh3/Polytope.h>
namespace archgraph
{
class Variant;
class Geometry
{
public:
Geometry(const pm3::PolytopePtr& poly)
: m_poly(poly)
{
m_color.MakeInvalid();
}
Geometry(const std::vector<std::shared_ptr<Geometry>>& children)
: m_children(children)
{
}
auto GetPoly() const { return m_poly; }
auto& GetColor() const { return m_color; }
void SetColor(const sm::vec3& color) { m_color = color; }
auto& GetFilepath() const { return m_filepath; }
void SetFilepath(const std::string& filepath) { m_filepath = filepath; }
auto& GetChildren() const { return m_children; }
void AddAttr(const std::string& name, const std::shared_ptr<Variant>& value);
bool SetAttr(const std::string& name, const std::shared_ptr<Variant>& value);
std::shared_ptr<Variant> QueryAttr(const std::string& name) const;
private:
pm3::PolytopePtr m_poly = nullptr;
sm::vec3 m_color;
std::string m_filepath;
std::vector<std::shared_ptr<Geometry>> m_children;
std::map<std::string, std::shared_ptr<Variant>> m_attrs;
}; // Geometry
}
|
xzrunner/ce
|
include/archgraph/RelativeFloat.h
|
<filename>include/archgraph/RelativeFloat.h
#pragma once
namespace archgraph
{
struct RelativeFloat
{
float value = 0;
bool relative = true;
RelativeFloat() {}
RelativeFloat(float value, bool relative = true)
: value(value), relative(relative) {}
bool operator != (const RelativeFloat& s) const {
return value != s.value || relative != s.relative;
}
};
}
|
xzrunner/ce
|
include/archgraph/op/Extrude.parm.h
|
<reponame>xzrunner/ce
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(Type, archgraph::op::Extrude::ExtrusionType, type, m_type, (archgraph::op::Extrude::ExtrusionType::FaceNormal))
PARAM_INFO(Distance, float, distance, m_distance, (0.0f))
|
xzrunner/ce
|
include/archgraph/FuncRegister.h
|
<filename>include/archgraph/FuncRegister.h<gh_stars>0
#pragma once
#include "archgraph/typedef.h"
#include <cu/cu_macro.h>
#include <map>
#include <string>
namespace archgraph
{
class Function;
class FuncRegister
{
public:
FuncPtr QueryFunc(const std::string& name) const;
FuncPtr QueryAttrFunc(const std::string& name) const;
private:
void InitFuncs();
private:
std::map<std::string, FuncPtr> m_funcs;
std::map<std::string, FuncPtr> m_attr_funcs;
CU_SINGLETON_DECLARATION(FuncRegister)
}; // FuncRegister
}
|
xzrunner/ce
|
include/archgraph/OpVarType.h
|
#pragma once
namespace archgraph
{
enum class OpVarType
{
Any,
Primitive,
};
}
|
xzrunner/ce
|
include/archgraph/op/Insert.parm.h
|
<gh_stars>0
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(GeoPath, std::string, geo_path, m_geo_path, ())
PARAM_INFO(UpAxisOfGeo, archgraph::op::Insert::UpAxisOfGeo, up_axis, m_up_axis, (archgraph::op::Insert::UpAxisOfGeo::UpY))
PARAM_INFO(InsertMode, archgraph::op::Insert::InsertMode, insert_mode, m_insert_mode, (archgraph::op::Insert::InsertMode::AlignSizeAndPosition))
|
xzrunner/ce
|
include/archgraph/ShapeAttrFuncs.h
|
#pragma once
#include "archgraph/Function.h"
namespace archgraph
{
namespace func
{
// scope attribute
class ScopeSizeX : public Function
{
public:
virtual VarPtr Eval(const std::vector<VarPtr>& parms,
const std::vector<GeoPtr>& geos, std::ostream& console) const override;
}; // ScopeSizeX
}
}
|
xzrunner/ce
|
include/archgraph/Function.h
|
<filename>include/archgraph/Function.h
#pragma once
#include "archgraph/typedef.h"
#include <vector>
namespace archgraph
{
class Function
{
public:
virtual VarPtr Eval(const std::vector<VarPtr>& parms,
const std::vector<GeoPtr>& geos, std::ostream& console) const = 0;
}; // Function
}
|
xzrunner/ce
|
include/archgraph/op/Comp.parm.h
|
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(Type, archgraph::op::Comp::Type, type, m_type, (archgraph::op::Comp::Type::Faces))
PARAM_INFO(Selector, std::vector<archgraph::op::Comp::Selector>, selectors, m_selectors, ())
|
xzrunner/ce
|
include/archgraph/op/Switch.parm.h
|
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(CaseExprStrings, std::vector<std::string>, case_expr_strs, m_case_expr_strs, ({""}))
|
xzrunner/ce
|
include/archgraph/op/ShapeO.parm.h
|
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(FrontWidth, float, front_width, m_front_width, (0.0f))
PARAM_INFO(RightWidth, float, right_width, m_right_width, (0.0f))
PARAM_INFO(BackWidth, float, back_width, m_back_width, (0.0f))
PARAM_INFO(LeftWidth, float, left_width, m_left_width, (0.0f))
|
xzrunner/ce
|
include/archgraph/op/TransScope.parm.h
|
<reponame>xzrunner/ce
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(TransX, archgraph::RelativeFloat, tx, m_tx, ())
PARAM_INFO(TransY, archgraph::RelativeFloat, ty, m_ty, ())
PARAM_INFO(TransZ, archgraph::RelativeFloat, tz, m_tz, ())
|
xzrunner/ce
|
include/archgraph/op/PrimPoly.parm.h
|
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(Vertices, std::vector<sm::vec2>, vertices, m_vertices, ())
|
xzrunner/ce
|
include/archgraph/TopoPolyAdapter.h
|
<reponame>xzrunner/ce
#pragma once
#include <SM_Vector.h>
#include <SM_Matrix.h>
#include <polymesh3/Polytope.h>
#include <vector>
#include <memory>
namespace he { class Polygon; }
namespace archgraph
{
class TopoPolyAdapter
{
public:
TopoPolyAdapter(const std::vector<sm::vec3>& border);
auto& GetPoly() const { return m_poly; }
void TransToPolymesh(std::vector<pm3::Polytope::PointPtr>& dst_pts,
std::vector<pm3::Polytope::FacePtr>& dst_faces) const;
private:
std::unique_ptr<he::Polygon> m_poly = nullptr;
sm::mat4 m_inv_rot;
}; // GeoHelper
}
|
xzrunner/ce
|
include/archgraph/op/Offset.parm.h
|
<reponame>xzrunner/ce<filename>include/archgraph/op/Offset.parm.h
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(Selector, archgraph::op::Offset::Selector, selector, m_selector, (archgraph::op::Offset::Selector::All))
PARAM_INFO(Distance, float, distance, m_distance, (0.0f))
|
xzrunner/ce
|
include/archgraph/op/Split.parm.h
|
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(Axis, archgraph::op::Split::Axis, axis, m_axis, (archgraph::op::Split::Axis::X))
PARAM_INFO(Parts, std::vector<archgraph::op::Split::Part>, parts, m_parts, ())
PARAM_INFO(Repeat, bool, repeat, m_repeat, (false))
|
xzrunner/ce
|
include/archgraph/op/Split.h
|
<reponame>xzrunner/ce<filename>include/archgraph/op/Split.h
#pragma once
#include "archgraph/Operation.h"
#include <SM_Vector.h>
#include <halfedge/typedef.h>
namespace archgraph
{
namespace op
{
class Split : public Operation
{
public:
enum class Axis
{
X,
Y,
Z
};
enum class SizeType
{
None,
Absolute,
Relative,
Floating,
};
struct Part
{
SizeType size_type = SizeType::None;
float size = 0;
bool repeat = false;
std::vector<Part> children;
Part() {}
Part(SizeType size_type, float size, bool repeat = false);
bool operator == (const Part& p) const;
float CalcAbsoluteSize() const;
float CalcRelativeSize() const;
bool IsRepeat() const;
bool IsAbsolute() const;
bool IsFloating() const;
bool IsInvalid() const { return size_type == SizeType::None && children.empty(); }
};
public:
Split()
{
m_imports = {
{{ OpVarType::Any, "in" }},
};
m_exports = {
{{ OpVarType::Any, "out" }},
};
}
virtual void OnParmChanged(const std::string& parm_name) override;
virtual void Execute(const std::vector<GeoPtr>& in, std::vector<GeoPtr>& out,
const EvalContext& ctx) override;
virtual void Setup(const std::vector<cga::ExprNodePtr>& parms,
const Rule::CompoundSel& selectors, const EvalContext& ctx) override;
void SetupExports();
private:
void AddAttr(const std::vector<GeoPtr>& geos) const;
void Execute(const sm::vec3& normal, const GeoPtr& in,
std::vector<GeoPtr>& out, const EvalContext& ctx);
private:
struct CutContext
{
CutContext(const sm::vec3& normal, const he::PolyhedronPtr& poly)
: normal(normal), curr_poly(poly) {}
float last_pos = -1;
const sm::vec3 normal;
he::PolyhedronPtr curr_poly = nullptr;
};
private:
static std::vector<GeoPtr> CutGeo(float begin, float end, CutContext& ctx,
const std::vector<Part>& parts, bool repeat);
static std::vector<GeoPtr> CutGeoNoRepeat(float& begin, float end, CutContext& ctx,
const std::vector<Part>& parts);
static std::vector<float> CalcPartCutSizes(float begin, float end, const std::vector<Part>& parts);
static Part SelectorToPart(const Rule::SelPtr& selector, const EvalContext& ctx);
static he::PolyhedronPtr CutSingle(float pos, CutContext& ctx);
RTTR_ENABLE(Operation)
#define PARM_FILEPATH "archgraph/op/Split.parm.h"
#include <dag/node_parms_gen.h>
#undef PARM_FILEPATH
}; // Split
}
}
|
xzrunner/ce
|
include/archgraph/Rule.h
|
#pragma once
#include "archgraph/typedef.h"
#include <cga/typedef.h>
#include <vector>
#include <memory>
#include <map>
namespace archgraph
{
class Operation;
class EvalContext;
class Rule
{
public:
struct Operator;
using OpPtr = std::shared_ptr<Operator>;
struct Selector
{
enum class Type
{
Single,
Compound,
};
virtual Type GetType() const = 0;
bool repeat = false;
};
using SelPtr = std::shared_ptr<Selector>;
struct SingleSel : public Selector
{
virtual Type GetType() const override { return Type::Single; }
cga::ExprNodePtr head = nullptr;
std::vector<OpPtr> ops;
};
struct CompoundSel : public Selector
{
virtual Type GetType() const override { return Type::Compound; }
std::vector<SelPtr> sels;
};
enum class OpType
{
Unknown = 0,
Rule,
Operation,
Func,
};
struct Operator
{
std::string name;
std::vector<cga::ExprNodePtr> params;
CompoundSel selectors;
OpType type = OpType::Unknown;
std::weak_ptr<Rule> rule;
std::shared_ptr<Operation> op = nullptr;
FuncPtr func = nullptr;
void Deduce(const std::map<std::string, RulePtr>& rules, const EvalContext& ctx);
};
public:
Rule(const std::string& name, const std::vector<std::string>& params = std::vector<std::string>());
auto& GetName() const { return m_name; }
auto& GetParams() const { return m_params; }
auto& GetAllOps() const { return m_ops; }
void AddOperator(const OpPtr& op);
private:
std::string m_name;
std::vector<std::string> m_params;
std::vector<OpPtr> m_ops;
}; // Rule
}
|
xzrunner/ce
|
include/archgraph/op_include_gen.h
|
<reponame>xzrunner/ce
#define XSTR(s) STR(s)
#define STR(s) #s
#ifndef PARM_OP_CLASS
#error "You must define PARM_OP_CLASS macro before include this file"
#endif
#ifndef PARM_FILEPATH_H
#define PARM_FILEPATH_H archgraph/op/##PARM_OP_CLASS##.h
#endif
#include XSTR(PARM_FILEPATH_H)
#undef PARM_OP_NAME
#undef PARM_OP_CLASS
#undef PARM_FILEPATH_H
|
xzrunner/ce
|
include/archgraph/EvalExpr.h
|
#pragma once
#include "archgraph/typedef.h"
#include <cga/typedef.h>
#include <memory>
namespace archgraph
{
class EvalContext;
class EvalExpr
{
public:
static VarPtr Eval(const cga::ExprNodePtr& expr,
const EvalContext& ctx, const GeoPtr& geo = nullptr);
static VarPtr EvalNoExpand(const cga::ExprNodePtr& expr,
const EvalContext& ctx, const GeoPtr& geo = nullptr);
}; // EvalExpr
}
|
xzrunner/ce
|
include/archgraph/op/Color.parm.h
|
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(Color, sm::vec3, color, m_color, (1.0f, 1.0f, 1.0f))
|
xzrunner/ce
|
include/archgraph/Variant.h
|
#pragma once
#include "archgraph/VarType.h"
#include <string>
namespace archgraph
{
class Variant
{
public:
virtual VarType Type() const = 0;
}; // Variant
class BoolVar : public Variant
{
public:
explicit BoolVar(bool b) : m_val(b) {}
virtual VarType Type() const override {
return VarType::Boolean;
}
auto& GetValue() const { return m_val; }
private:
bool m_val;
}; // BoolVar
class FloatVar : public Variant
{
public:
explicit FloatVar(float f) : m_val(f) {}
virtual VarType Type() const override {
return VarType::Float;
}
auto& GetValue() const { return m_val; }
private:
float m_val;
}; // FloatVar
class StringVar : public Variant
{
public:
explicit StringVar(const std::string& str) : m_val(str) {}
virtual VarType Type() const override {
return VarType::String;
}
auto& GetValue() const { return m_val; }
private:
std::string m_val;
}; // StringVar
bool check_bool(const std::shared_ptr<Variant>& var);
float check_float(const std::shared_ptr<Variant>& var);
std::string check_string(const std::shared_ptr<Variant>& var);
}
|
xzrunner/ce
|
include/archgraph/op/Scale.parm.h
|
<gh_stars>0
#ifndef PARAM_INFO
#error "You must define PARAM_INFO macro before include this file"
#endif
PARAM_INFO(ScaleX, archgraph::RelativeFloat, sx, m_sx, ())
PARAM_INFO(ScaleY, archgraph::RelativeFloat, sy, m_sy, ())
PARAM_INFO(ScaleZ, archgraph::RelativeFloat, sz, m_sz, ())
|
xzrunner/ce
|
include/archgraph/VarType.h
|
<reponame>xzrunner/ce<filename>include/archgraph/VarType.h<gh_stars>0
#pragma once
namespace archgraph
{
enum class VarType
{
Boolean,
Float,
String,
};
}
|
xzrunner/ce
|
include/archgraph/BuildInFuncs.h
|
#pragma once
#include "archgraph/Function.h"
namespace archgraph
{
namespace func
{
class Print : public Function
{
public:
virtual VarPtr Eval(const std::vector<VarPtr>& parms,
const std::vector<GeoPtr>& geos, std::ostream& console) const override;
private:
static void PrintVar(const VarPtr& var, const std::vector<GeoPtr>& geos, std::ostream& console);
}; // Print
}
}
|
xzrunner/ce
|
include/archgraph/op/Scale.h
|
#pragma once
#include "archgraph/Operation.h"
#include "archgraph/EvalExpr.h"
#include "archgraph/RelativeFloat.h"
namespace archgraph
{
namespace op
{
class Scale : public Operation
{
public:
Scale()
{
m_imports = {
{{ OpVarType::Any, "in" }},
};
m_exports = {
{{ OpVarType::Any, "out" }},
};
}
virtual void Execute(const std::vector<GeoPtr>& in, std::vector<GeoPtr>& out,
const EvalContext& ctx) override;
virtual void Setup(const std::vector<cga::ExprNodePtr>& parms,
const Rule::CompoundSel& selectors, const EvalContext& ctx) override;
RTTR_ENABLE(Operation)
#define PARM_FILEPATH "archgraph/op/Scale.parm.h"
#include <dag/node_parms_gen.h>
#undef PARM_FILEPATH
}; // Scale
}
}
|
xzrunner/ce
|
include/archgraph/EvalContext.h
|
<reponame>xzrunner/ce<filename>include/archgraph/EvalContext.h<gh_stars>0
#pragma once
#include <dag/Variable.h>
#include <cga/typedef.h>
#include <vector>
namespace archgraph
{
class EvalContext
{
public:
struct Parm
{
Parm() {}
Parm(const std::string& name, const dag::Variable& value);
Parm(const std::string& name, const cga::ExprNodePtr& expr);
std::string name;
dag::Variable value;
cga::ExprNodePtr expr = nullptr;
};
public:
void AddVar(const Parm& var);
void DeleteVar(const std::string& name);
const Parm* QueryVar(const std::string& name) const;
void SetVars(const std::vector<Parm>& vars) { m_vars = vars; }
auto& GetVars() const { return m_vars; }
void Clear() { m_vars.clear(); }
private:
std::vector<Parm> m_vars;
}; // EvalContext
}
|
xzrunner/ce
|
include/archgraph/typedef.h
|
#pragma once
#include <memory>
namespace archgraph
{
class Operation;
using OpPtr = std::shared_ptr<Operation>;
class Geometry;
using GeoPtr = std::shared_ptr<Geometry>;
class Rule;
using RulePtr = std::shared_ptr<Rule>;
class Function;
using FuncPtr = std::shared_ptr<Function>;
class Variant;
using VarPtr = std::shared_ptr<Variant>;
}
|
xzrunner/ce
|
include/archgraph/RuleLoader.h
|
#pragma once
#include "archgraph/Rule.h"
#include <cga/typedef.h>
#include <string>
#include <map>
#include <vector>
namespace cga
{
struct ExpressionNode;
struct StatementNode;
class Parser;
class StringPool;
}
namespace archgraph
{
class EvalRule;
class RuleLoader
{
public:
RuleLoader(const std::shared_ptr<cga::StringPool>& str_pool = nullptr);
bool RunString(const EvalContext& ctx, const std::string& str,
EvalRule& eval, bool debug = false);
private:
struct Context
{
std::vector<Rule::SelPtr> selectors;
std::vector<Rule::OpPtr> operators;
void FlushOperators(const RulePtr& rule);
void FlushSelectors(bool repeat);
};
private:
cga::StmtNodePtr LoadStatement(EvalRule& eval, const cga::StmtNodePtr& stmt,
Context& ctx, const EvalContext& eval_ctx);
void LoadExpression(EvalRule& eval, const cga::ExprNodePtr& expr,
Context& ctx, const EvalContext& eval_ctx);
private:
std::shared_ptr<cga::StringPool> m_str_pool = nullptr;
std::vector<std::shared_ptr<cga::Parser>> m_parsers;
}; // RuleLoader
}
|
xzrunner/ce
|
include/archgraph/op/Comp.h
|
#pragma once
#include "archgraph/Operation.h"
namespace archgraph
{
namespace op
{
class Comp : public Operation
{
public:
enum class Type
{
Faces,
Edges,
FaceEdges,
Vertices,
Groups,
Materials,
Holes,
};
enum class Selector
{
// The y-normals of the components are analyzed by classifying their directions into the corresponding quadrants (in relation to the local coordinate system of the current shape).
Front,
Back,
Left,
Right,
Top,
Bottom,
// The y-normals of the components are analyzed by classifying their directions into the corresponding quadrants (in relation to the object coordinate system of the current initial shape).
ObjFront,
ObjBack,
ObjLeft,
ObjRight,
ObjTop,
ObjBottom,
ObjSide,
// The y-normals of the components are analyzed by classifying their directions into the corresponding quadrants (in relation to the world coordinate system).
WorldSouth,
WorldNorth,
WorldWest,
WorldEast,
WorldUp,
WorldDown,
WorldSide,
// The y-normals are analyzed in relation to the xz-plane of the current shape's local coordinate system. The angle between normals and xz-plane is used to classify the components with the ranges in degrees: horizontal: ]78.75, 90] aslant: ]11.25, 78.75] vertical: ] - 11.25, 11.25] nutant: ] - 78.55, -11.25] horizontal: ] - 90, -78.75]
Vertical,
Horizontal,
Aslant,
Nutant,
// selects all but the horizontal components.
Side,
// components at the border of or fully inside the geometry respectively. Border edges are connected to only one face; border faces contain one or more border edges; border vertices are start or end point of one or more border edges. This selector does not work on holes.
Border,
Inside,
// these selectors work on edges only and are designed to be used in conjunction with roofs. See roof edges for more details.
Eave,
Hip,
Valley,
Ridge,
// if the streetWidth attribute is available on the initial shape, these selectors can be used to identify street-facing components. See street selectors for more details.
StreetFront,
StreetBack,
StreetLeft,
StreetRight,
StreetSide,
// selects all components.
All,
// selects the index-th component (0-based).
Index,
};
public:
Comp()
{
m_imports = {
{{ OpVarType::Any, "in" }},
};
SetupExports();
}
virtual void Execute(const std::vector<GeoPtr>& in, std::vector<GeoPtr>& out,
const EvalContext& ctx) override;
virtual void Setup(const std::vector<cga::ExprNodePtr>& parms,
const Rule::CompoundSel& selectors, const EvalContext& ctx) override;
void SetupExports();
private:
static GeoPtr BuildComp(const GeoPtr& geo, Selector sel);
static GeoPtr BuildFace6(const GeoPtr& geo, Selector sel);
static GeoPtr BuildBorderInside(const GeoPtr& geo, Selector sel);
static GeoPtr BuildNormalY(const GeoPtr& geo, Selector sel);
static GeoPtr BuildSide(const GeoPtr& geo);
static GeoPtr BuildAll(const GeoPtr& geo);
RTTR_ENABLE(Operation)
#define PARM_FILEPATH "archgraph/op/Comp.parm.h"
#include <dag/node_parms_gen.h>
#undef PARM_FILEPATH
}; // Comp
}
}
|
MbedCraft/mc_btplayer
|
main/src/btplayer.c
|
#include <stdio.h>
#include <string.h>
#include "esp_console.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_system.h"
#include "mc_bt.h"
#include "mc_fs.h"
#include "mc_nvs.h"
#include "app_console.h"
#include "app_btplayer.h"
const char _mount_path[] = "/data";
void app_main(void)
{
/*
* NVS is used to store some secrets (credentials) as well as the
* PHY calibration data
*/
mc_nvs_init();
/*
* Console command history can be stored to and loaded from a file.
* The easiest way to do this is to use FATFS filesystem on top of
* wear_levelling library.
*/
mc_fs_init(_mount_path);
mc_bt_init(CONFIG_BT_DEVICE_NAME);
ESP_ERROR_CHECK(esp_netif_init());
ESP_ERROR_CHECK(esp_event_loop_create_default());
app_console_init(_mount_path, sizeof(_mount_path));
app_btplayer_init(_mount_path, sizeof(_mount_path));
}
|
MbedCraft/mc_btplayer
|
main/src/app_console.c
|
<filename>main/src/app_console.c<gh_stars>0
/* ------------------------------------------------------------------------- *\
* Standard Includes
* ------------------------------------------------------------------------- */
#include <stdio.h>
#include <string.h>
/* ------------------------------------------------------------------------- *\
* FreeRTOS specific includes
* ------------------------------------------------------------------------- */
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/* ------------------------------------------------------------------------- *\
* Espressif specific includes
* ------------------------------------------------------------------------- */
#include "esp_console.h"
#include "esp_system.h"
#include "esp_log.h"
#include "argtable3/argtable3.h"
#include "linenoise/linenoise.h"
/* ------------------------------------------------------------------------- *\
* MbedCraft includes
* ------------------------------------------------------------------------- */
#include "mc_cmd_aac.h"
#include "mc_cmd_fs.h"
#include "mc_cmd_nvs.h"
#include "mc_cmd_system.h"
#include "mc_console.h"
#include "mc_nvs.h"
#include "mc_fs.h"
#include "app_btplayer.h"
#define CONSOLE_TASK_STACK_SIZE 4*1024
#define CONSOLE_TASK_PRIORITY 2
#ifdef CONFIG_ESP_CONSOLE_USB_CDC
#error This example is incompatible with USB CDC console. Please try "console_usb" example instead.
#endif // CONFIG_ESP_CONSOLE_USB_CDC
const char prompt_str[] = CONFIG_IDF_TARGET;
const char _history_filename[] = "history.txt";
char * history_path;
void app_console_task(void * v_param) {
mc_console_run(prompt_str, sizeof(prompt_str));
/* Delete the task when the console is closed */
vTaskDelete(NULL);
free(history_path);
}
void app_console_init(const char * const mount_path, size_t mount_path_size) {
int history_path_size = mount_path_size + 1 + sizeof(_history_filename);
history_path = malloc(history_path_size);
strlcpy(history_path, mount_path, mount_path_size);
strlcat(history_path, "/", mount_path_size+1);
strlcat(history_path, _history_filename, history_path_size);
mc_console_init(history_path);
/* Register console commands */
mc_cmd_system_register();
mc_cmd_nvs_register();
mc_cmd_fs_register();
mc_cmd_aac_register();
/* Start tasks */
BaseType_t err = xTaskCreate(
app_console_task,
"console_task",
CONSOLE_TASK_STACK_SIZE,
NULL,
CONSOLE_TASK_PRIORITY,
NULL);
if (err != pdTRUE) {
ESP_LOGE(__func__, "Create console_task failed");
}
}
|
MbedCraft/mc_btplayer
|
main/inc/app_btplayer.h
|
<reponame>MbedCraft/mc_btplayer
#pragma once
#include <stddef.h>
void app_btplayer_i2s_config(
int sample_rate,
int bits_per_sample,
int channels);
void app_byplayer_i2s_send_data(const uint8_t *buf, uint32_t len);
void app_btplayer_init(const char * const mount_path, size_t mount_path_size);
|
MbedCraft/mc_btplayer
|
main/inc/app_console.h
|
<gh_stars>0
#if !defined __APP_CONSOLE_H__
# define __APP_CONSOLE_H__
void app_console_init(const char * const mount_path, size_t mount_path_size);
#endif // __APP_CONSOLE_H__
|
MbedCraft/mc_btplayer
|
main/src/app_btplayer.c
|
/* ------------------------------------------------------------------------- *\
* Standard Includes
* ------------------------------------------------------------------------- */
#include <string.h>
/* ------------------------------------------------------------------------- *\
* Espressif specific includes
* ------------------------------------------------------------------------- */
#include "driver/i2s.h"
#include "esp_log.h"
/* ------------------------------------------------------------------------- *\
* MbedCraft includes
* ------------------------------------------------------------------------- */
#include "app_btplayer.h"
#include "mc_aac.h"
#include "mc_assert.h"
#include "mc_bt_a2dp.h"
#include "mc_bt_gap.h"
/* ------------------------------------------------------------------------- *\
* Private function definitions
* ------------------------------------------------------------------------- */
static void __a2dp_config_cb(esp_a2d_mcc_t *mcc);
static void __a2dp_connection_cb(bool connected);
static bool __gap_cfm_req_cb(uint32_t num_val);
static void __i2s_init(void);
/* ------------------------------------------------------------------------- *\
* Private variables
* ------------------------------------------------------------------------- */
static int __cur_bits_per_sample;
static int __cur_sample_rate;
static int __cur_channels;
static const char __sounds_dir[] = "/data/sounds/aac/";
static const char __sound_conn_pass_is_fn[] = "conn_pass_is.aac";
static const char __sound_connected_fn[] = "connected.aac";
static const char __sound_disconnected_fn[] = "disconnected.aac";
static const char __sound_digits_fn[][6] = {
"0.aac",
"1.aac",
"2.aac",
"3.aac",
"4.aac",
"5.aac",
"6.aac",
"7.aac",
"8.aac",
"9.aac",
};
/* ------------------------------------------------------------------------- *\
* Public function implementations
* ------------------------------------------------------------------------- */
void app_btplayer_init(const char * const mount_path, size_t mount_path_size) {
__i2s_init();
mc_aac_init(app_btplayer_i2s_config, app_byplayer_i2s_send_data);
mc_bt_gap_register_cfm_req_cb(__gap_cfm_req_cb);
mc_bt_a2dp_register_connection_cb(__a2dp_connection_cb);
mc_bt_a2dp_register_configuration_cb(__a2dp_config_cb);
mc_bt_a2dp_register_data_cb(app_byplayer_i2s_send_data);
}
void app_btplayer_i2s_config(
int sample_rate,
int bits_per_sample,
int channels) {
if ( 0
|| (sample_rate != __cur_sample_rate)
|| (bits_per_sample != __cur_bits_per_sample)
|| (channels != __cur_channels)) {
__cur_sample_rate = sample_rate;
__cur_bits_per_sample = bits_per_sample;
__cur_channels = channels;
ESP_LOGI(__func__, "Reconfiguring i2s: sample_rate(%d), bit_per_sample(%d), channels(%d)",
__cur_sample_rate, __cur_bits_per_sample, __cur_channels);
i2s_set_clk(0, sample_rate, bits_per_sample, channels);
}
}
void app_byplayer_i2s_send_data(const uint8_t *buf, uint32_t len) {
size_t bytes_written = 0;
i2s_write(0, buf, len, &bytes_written, portMAX_DELAY);
}
/* ------------------------------------------------------------------------- *\
* Private function implementations
* ------------------------------------------------------------------------- */
static void __i2s_init(void) {
__cur_bits_per_sample = 16;
__cur_sample_rate = 44100;
__cur_channels = 2;
i2s_config_t i2s_config = {
.mode = I2S_MODE_MASTER | I2S_MODE_TX, // Only TX
.sample_rate = __cur_sample_rate,
.bits_per_sample = __cur_bits_per_sample,
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT, //2-channels
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.dma_buf_count = 6,
.dma_buf_len = 60,
.intr_alloc_flags = 0, //Default interrupt priority
.tx_desc_auto_clear = true //Auto clear tx descriptor on underflow
};
i2s_driver_install(0, &i2s_config, 0, NULL);
i2s_pin_config_t pin_config = {
.bck_io_num = CONFIG_I2S_BCK_PIN,
.ws_io_num = CONFIG_I2S_WS_PIN,
.data_out_num = CONFIG_I2S_DATA_PIN,
.data_in_num = -1 //Not used
};
i2s_set_pin(0, &pin_config);
}
int __build_path_and_play(const char * const filename, int filename_size) {
size_t ret;
char path[64];
ret = strlcpy(path, __sounds_dir, sizeof(path));
ASSERTE_RET(ret == sizeof(__sounds_dir) - 1, -1,
"Internal error 1: %d", ret);
ret = strlcat(path, filename, sizeof(path));
ASSERTE_RET(ret == sizeof(__sounds_dir) + filename_size - 2, -1,
"Internal error 2: %d", ret);
mc_aac_play_file(path);
return 0;
}
static void __a2dp_connection_cb(bool connected) {
if (true == connected) {
__build_path_and_play(
__sound_connected_fn,
sizeof(__sound_connected_fn));
// Configuring i2s for default a2dp settings
// FIXME: Check is A2DP module should not call the
// __a2dp_config_cb callback at connection instead
app_btplayer_i2s_config(44100, 16, 2);
} else {
__build_path_and_play(
__sound_disconnected_fn,
sizeof(__sound_conn_pass_is_fn));
}
}
static bool __gap_cfm_req_cb(uint32_t num_val) {
int digits[16];
int nb_digits;
ESP_LOGI(__func__, "Please compare the numeric value: %d", num_val);
__build_path_and_play(
__sound_conn_pass_is_fn,
sizeof(__sound_conn_pass_is_fn));
for (nb_digits = 0; num_val != 0; nb_digits++) {
ASSERTE_RET(nb_digits < (sizeof(digits)/sizeof(digits[0])), -1,
"Confirmation password is too long");
digits[nb_digits] = num_val % 10;
num_val /= 10;
}
while (nb_digits--) {
__build_path_and_play(
__sound_digits_fn[digits[nb_digits]],
sizeof(__sound_digits_fn[digits[nb_digits]]));
}
return true;
}
static void __a2dp_config_cb(esp_a2d_mcc_t *mcc) {
if (mcc->type == ESP_A2D_MCT_SBC) {
int sample_rate = 16000;
char oct0 = mcc->cie.sbc[0];
if (oct0 & (0x01 << 6)) {
sample_rate = 32000;
} else if (oct0 & (0x01 << 5)) {
sample_rate = 44100;
} else if (oct0 & (0x01 << 4)) {
sample_rate = 48000;
}
app_btplayer_i2s_config(sample_rate, 16, 2);
ESP_LOGI(__func__, "Configure audio player %x-%x-%x-%x",
mcc->cie.sbc[0],
mcc->cie.sbc[1],
mcc->cie.sbc[2],
mcc->cie.sbc[3]);
ESP_LOGI(__func__, "Audio player configured, sample rate=%d", sample_rate);
}
}
|
dxinteractive/xmas-steps
|
xmas.h
|
#include "Arduino.h"
class Xmas
{
public:
void setup();
void loop();
//Ledset ledset[3];
//int brightness = 255;
};
|
cvxgrp/coneos
|
coneOSsparse/cs.c
|
<filename>coneOSsparse/cs.c
#include "cs.h"
#include "coneOS.h"
/* NB: this is a subset of the routines in the CSPARSE package by
<NAME>. al., for the full package please visit
http://www.cise.ufl.edu/research/sparse/CSparse/ */
#define CS_MAX(a,b) (((a) > (b)) ? (a) : (b))
#define CS_MIN(a,b) (((a) < (b)) ? (a) : (b))
/* wrapper for malloc */
static inline void *cs_malloc (int n, int size)
{
return (coneOS_malloc (n * size)) ;
}
/* wrapper for calloc */
static inline void *cs_calloc (int n, int size)
{
return (coneOS_calloc (n, size)) ;
}
/* wrapper for free */
static inline void *cs_free (void *p)
{
if (p) coneOS_free (p) ; /* free p if it is not already NULL */
return (NULL) ; /* return NULL to simplify the use of cs_free */
}
/* C = compressed-column form of a triplet matrix T */
cs *cs_compress (const cs *T)
{
int m, n, nz, p, k, *Cp, *Ci, *w, *Ti, *Tj ;
double *Cx, *Tx ;
cs *C ;
m = T->m ; n = T->n ; Ti = T->i ; Tj = T->p ; Tx = T->x ; nz = T->nz ;
C = cs_spalloc (m, n, nz, Tx != NULL, 0) ; /* allocate result */
w = cs_calloc (n, sizeof (int )) ; /* get workspace */
if (!C || !w) return (cs_done (C, w, NULL, 0)) ; /* out of memory */
Cp = C->p ; Ci = C->i ; Cx = C->x ;
for (k = 0 ; k < nz ; k++) w [Tj [k]]++ ; /* column counts */
cs_cumsum (Cp, w, n) ; /* column pointers */
for (k = 0 ; k < nz ; k++)
{
Ci [p = w [Tj [k]]++] = Ti [k] ; /* A(i,j) is the pth entry in C */
if (Cx) Cx [p] = Tx [k] ;
}
return (cs_done (C, w, NULL, 1)) ; /* success; free w and return C */
}
cs *cs_done (cs *C, void *w, void *x, int ok)
{
cs_free (w) ; /* free workspace */
cs_free (x) ;
return (ok ? C : cs_spfree (C)) ; /* return result if OK, else free it */
}
cs *cs_spalloc (int m, int n, int nzmax, int values, int triplet)
{
cs *A = cs_calloc (1, sizeof (cs)) ; /* allocate the cs struct */
if (!A) return (NULL) ; /* out of memory */
A->m = m ; /* define dimensions and nzmax */
A->n = n ;
A->nzmax = nzmax = CS_MAX (nzmax, 1) ;
A->nz = triplet ? 0 : -1 ; /* allocate triplet or comp.col */
A->p = cs_malloc (triplet ? nzmax : n+1, sizeof (int)) ;
A->i = cs_malloc (nzmax, sizeof (int)) ;
A->x = values ? cs_malloc (nzmax, sizeof (double)) : NULL ;
return ((!A->p || !A->i || (values && !A->x)) ? cs_spfree (A) : A) ;
}
cs *cs_spfree (cs *A)
{
if (!A) return (NULL) ; /* do nothing if A already NULL */
cs_free (A->p) ;
cs_free (A->i) ;
cs_free (A->x) ;
return ((cs *) cs_free (A)) ; /* free the cs struct and return NULL */
}
double cs_cumsum (int *p, int *c, int n)
{
int i, nz = 0 ;
double nz2 = 0 ;
if (!p || !c) return (-1) ; /* check inputs */
for (i = 0 ; i < n ; i++)
{
p [i] = nz ;
nz += c [i] ;
nz2 += c [i] ; /* also in double to avoid int overflow */
c [i] = p [i] ; /* also copy p[0..n-1] back into c[0..n-1]*/
}
p [n] = nz ;
return (nz2) ; /* return sum (c [0..n-1]) */
}
int *cs_pinv (int const *p, int n)
{
int k, *pinv ;
if (!p) return (NULL) ; /* p = NULL denotes identity */
pinv = cs_malloc (n, sizeof (int)) ; /* allocate result */
if (!pinv) return (NULL) ; /* out of memory */
for (k = 0 ; k < n ; k++) pinv [p [k]] = k ;/* invert the permutation */
return (pinv) ; /* return result */
}
cs *cs_symperm (const cs *A, const int *pinv, int values)
{
int i, j, p, q, i2, j2, n, *Ap, *Ai, *Cp, *Ci, *w ;
double *Cx, *Ax ;
cs *C ;
n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
C = cs_spalloc (n, n, Ap [n], values && (Ax != NULL), 0) ; /* alloc result*/
w = cs_calloc (n, sizeof (int)) ; /* get workspace */
if (!C || !w) return (cs_done (C, w, NULL, 0)) ; /* out of memory */
Cp = C->p ; Ci = C->i ; Cx = C->x ;
for (j = 0 ; j < n ; j++) /* count entries in each column of C */
{
j2 = pinv ? pinv [j] : j ; /* column j of A is column j2 of C */
for (p = Ap [j] ; p < Ap [j+1] ; p++)
{
i = Ai [p] ;
if (i > j) continue ; /* skip lower triangular part of A */
i2 = pinv ? pinv [i] : i ; /* row i of A is row i2 of C */
w [CS_MAX (i2, j2)]++ ; /* column count of C */
}
}
cs_cumsum (Cp, w, n) ; /* compute column pointers of C */
for (j = 0 ; j < n ; j++)
{
j2 = pinv ? pinv [j] : j ; /* column j of A is column j2 of C */
for (p = Ap [j] ; p < Ap [j+1] ; p++)
{
i = Ai [p] ;
if (i > j) continue ; /* skip lower triangular part of A*/
i2 = pinv ? pinv [i] : i ; /* row i of A is row i2 of C */
Ci [q = w [CS_MAX (i2, j2)]++] = CS_MIN (i2, j2) ;
if (Cx) Cx [q] = Ax [p] ;
}
}
return (cs_done (C, w, NULL, 1)) ; /* success; free workspace, return C */
}
|
cvxgrp/coneos
|
coneOSdense/cones.c
|
#include "cones.h"
#ifdef LAPACK_LIB_FOUND
#include <cblas.h>
#include <lapacke.h>
#endif
void projectsdc(double * X, int n, Work * w);
/* in place projection (with branches) */
void projCone(double *x, Cone * k, Work * w)
{
int i;
int count;
/* project onto positive orthant */
for(i = k->f; i < k->f+k->l; ++i)
{
if(x[i] < 0.0) x[i] = 0.0;
//x[i] = (x[i] < 0.0) ? 0.0 : x[i];
}
count = k->l+k->f;
/* project onto SOC */
for(i = 0; i < k->qsize; ++i)
{
double v1 = x[count];
double s = calcNorm(&(x[count+1]),k->q[i]-1);
double alpha = (s + v1)/2.0;
if(s <= v1) { /* do nothing */ }
else if (s <= - v1) {
memset(&(x[count]), 0, k->q[i]*sizeof(double));
} else {
x[count] = alpha;
scaleArray(&(x[count+1]), alpha/s, k->q[i]-1);
//cblas_dscal(k->q[i]-1, alpha/s, &(x[count+1]),1);
}
count += k->q[i];
}
#ifdef LAPACK_LIB_FOUND
/* project onto PSD cone */
for (i=0; i < k->ssize; ++i){
projectsdc(&(x[count]),k->s[i],w);
count += (k->s[i])*(k->s[i]);
}
#else
if(k->ssize > 0){
coneOS_printf("WARNING: solving SDP, no lapack library specified in makefile!\n");
coneOS_printf("ConeOS will return a wrong answer!\n");
}
#endif
/* project onto OTHER cones */
}
#ifdef LAPACK_LIB_FOUND
void projectsdc(double *X, int n, Work * w)
{ /* project onto the positive semi-definite cone */
if (n == 1) {
if(X[0] < 0.0) X[0] = 0.0;
return;
}
int i, j, m=0;
double * Xs = w->Xs;
double * Z = w->Z;
double * e = w->e;
memcpy(Xs,X,n*n*sizeof(double));
// Xs = X + X', save div by 2 for eigen-recomp
for (i = 0; i < n; ++i){
cblas_daxpy(n, 1, &(X[i]), n, &(Xs[i*n]), 1);
//b_daxpy(n, 1, &(X[i]), n, &(Xs[i*n]), 1);
}
double EIG_TOL = 1e-8;
double vupper = calcNorm(Xs,n*n);
LAPACKE_dsyevr( LAPACK_COL_MAJOR, 'V', 'V', 'U', n, Xs, n, 0.0, vupper, -1, -1, EIG_TOL, &m, e, Z, n , NULL);
memset(X, 0, n*n*sizeof(double));
for (i = 0; i < m; ++i) {
cblas_dsyr(CblasColMajor, CblasLower, n, e[i]/2, &(Z[i*n]), 1, X, n);
//b_dsyr('L', n, -e[i]/2, &(Z[i*n]), 1, Xs, n);
}
// fill in upper half
for (i = 0; i < n; ++i){
for (j = i+1; j < n; ++j){
X[i + j*n] = X[j + i*n];
}
}
}
#endif
|
cvxgrp/coneos
|
coneOSsparse/util.c
|
#include "util.h"
#include <sys/time.h>
static struct timeval tic_timestart;
void tic(void) {
gettimeofday(&tic_timestart, NULL);
}
double tocq(void) {
struct timeval tic_timestop;
gettimeofday(&tic_timestop, NULL);
//coneOS_printf("time: %8.4f seconds.\n", (float)(tic_timestop - tic_timestart));
double time = tic_timestop.tv_sec*1e3 + tic_timestop.tv_usec/1e3 - tic_timestart.tv_sec*1e3 - tic_timestart.tv_usec/1e3;
return time;
}
double toc(void) {
double time = tocq();
coneOS_printf("time: %8.4f milli-seconds.\n", time);
return time;
}
void printConeData(Cone * k){
int i;
coneOS_printf("num zeros = %i\n",k->f);
coneOS_printf("num LP = %i\n",k->l);
coneOS_printf("num SOCs = %i\n",k->qsize);
coneOS_printf("soc array:\n");
for ( i=0;i<k->qsize;i++){
coneOS_printf("%i\n",k->q[i]);
}
coneOS_printf("num SDCs = %i\n",k->ssize);
coneOS_printf("sdc array:\n");
for ( i=0;i<k->ssize;i++){
coneOS_printf("%i\n",k->s[i]);
}
}
void printData(Data * d){
coneOS_printf("d->n is %i\n",d->n);
coneOS_printf("d->m is %i\n",d->m);
coneOS_printf("d->b[0] is %4f\n",d->b[0]);
coneOS_printf("d->c[0] is %4f\n",d->c[0]);
coneOS_printf("d->Ax[0] is %4f\n",d->Ax[0]);
coneOS_printf("d->MAX_ITERS is %i\n",d->MAX_ITERS);
coneOS_printf("d->VERBOSE is %i\n",d->VERBOSE);
coneOS_printf("d->NORMALIZE is %i\n",d->VERBOSE);
coneOS_printf("d->ALPH is %6f\n",d->ALPH);
coneOS_printf("d->EPS_ABS is %6f\n",d->EPS_ABS);
coneOS_printf("d->EPS_ABS is %6f\n",d->EPS_ABS);
coneOS_printf("d->UNDET_TOL is %6f\n",d->UNDET_TOL);
}
void printAll(Data * d, Work * w){
int i;
coneOS_printf("\n u_t is \n");
for( i=0;i<w->l;i++){
coneOS_printf("%f\n",w->u_t[i]);
}
coneOS_printf("\n u is \n");
for( i=0;i<w->l;i++){
coneOS_printf("%f\n",w->u[i]);
}
coneOS_printf("\n v is \n");
for( i=0;i<w->l;i++){
coneOS_printf("%f\n",w->v[i]);
}
}
|
cvxgrp/coneos
|
coneOSdense/coneOS.h
|
#ifndef coneOS_H_GUARD
#define coneOS_H_GUARD
// redefine printfs and memory allocators as needed
#ifdef MATLAB_MEX_FILE
#include "mex.h"
#define coneOS_printf mexPrintf
#define coneOS_free mxFree
#define coneOS_malloc mxMalloc
#define coneOS_calloc mxCalloc
#elif defined PYTHON
#include <Python.h>
#include <stdlib.h>
#define coneOS_printf PySys_WriteStdout
#define coneOS_free free
#define coneOS_malloc malloc
#define coneOS_calloc calloc
#else
#include <stdio.h>
#include <stdlib.h>
#define coneOS_printf printf
#define coneOS_free free
#define coneOS_malloc malloc
#define coneOS_calloc calloc
#endif
/* struct that containing standard problem data */
typedef struct PROBLEM_DATA {
int n, m; /* problem dimensions */
/* problem data, A, b, c: */
double * Ax;
int * Ai, * Ap;
int Anz;
double * b, * c;
int MAX_ITERS, CG_MAX_ITS;
double EPS_ABS, ALPH, CG_TOL, UNDET_TOL, RHO_X;
int VERBOSE, NORMALIZE; // boolean
} Data;
/* contains primal-dual solution vectors */
typedef struct SOL_VARS {
double * x, * y, *s;
} Sol;
/* contains terminating information */
typedef struct INFO {
int iter;
char status[16];
int stint; // status as int
double pobj;
double dobj;
double resPri;
double resDual;
double relGap;
double time;
} Info;
typedef struct PRIVATE_DATA Priv;
typedef struct WORK {
double *u, *v, *u_t, *u_prev;
double *h, *g;
double gTh, sc_b, sc_c, scale;
double nm_b, nm_c, nm_Q;
double *D, *E;
Priv * p;
/* workspace for eigenvector decompositions: */
double * Xs, *Z, *e;
int l;
char * method;
} Work;
// to hold residual information
struct residuals {
double resDual;
double resPri;
double relGap;
double cTx;
double bTy;
double tau;
double kap;
};
#include <string.h>
#include <sys/time.h>
#include <math.h>
#include "cones.h"
#include "linAlg.h"
#include "util.h"
// these are actually library "api"'s
int coneOS(Data * d, Cone * k, Sol * sol, Info * info);
// these are pulled in from private.o
int privateInitWork(Data * d, Work * w);
// solves [I A';A -I] x = b, stores result in b, s contains warm-start
void solveLinSys(Data * d, Work * w, double * b, const double * s);
void freePriv(Work * w);
#endif
|
cvxgrp/coneos
|
coneOSdense/indirect/private.h
|
#ifndef PRIV_H_GUARD
#define PRIV_H_GUARD
#include "coneOS.h"
#include "cblas.h"
struct PRIVATE_DATA{
double * x;
double * p;
double * r;
double * Ap;
/* Gram matrix */
double * G;
};
//Work * initWork(Data* d);
//void formQ(Data * d, Work * w);
//void freePriv(Work * w);
//void projectLinSys(Data * d,Work * w);
//void cgCustom(cs *Q,double * b,double * x,int max_its,double tol);
//void multByQ(const cs *Q, const double *x, double *y);
#endif
|
cvxgrp/coneos
|
coneOSsparse/cones.c
|
<reponame>cvxgrp/coneos<filename>coneOSsparse/cones.c
#include "cones.h"
#ifdef LAPACK_LIB_FOUND
#include <cblas.h>
#include <lapacke.h>
#endif
void projectsdc(double * X, int n, Work * w);
/* in place projection (with branches) */
void projCone(double *x, Cone * k, Work * w, int iter)
{
int i;
int count;
/* project onto positive orthant */
for(i = k->f; i < k->f+k->l; ++i)
{
if(x[i] < 0.0) x[i] = 0.0;
//x[i] = (x[i] < 0.0) ? 0.0 : x[i];
}
count = k->l+k->f;
/* project onto SOC */
for(i = 0; i < k->qsize; ++i)
{
double v1 = x[count];
double s = calcNorm(&(x[count+1]),k->q[i]-1);
double alpha = (s + v1)/2.0;
if(s <= v1) { /* do nothing */ }
else if (s <= - v1) {
memset(&(x[count]), 0, k->q[i]*sizeof(double));
} else {
x[count] = alpha;
scaleArray(&(x[count+1]), alpha/s, k->q[i]-1);
//cblas_dscal(k->q[i]-1, alpha/s, &(x[count+1]),1);
}
count += k->q[i];
}
#ifdef LAPACK_LIB_FOUND
/* project onto PSD cone */
for (i=0; i < k->ssize; ++i){
projectsdc(&(x[count]),k->s[i],w);
count += (k->s[i])*(k->s[i]);
}
#else
if(k->ssize > 0){
coneOS_printf("WARNING: solving SDP, no lapack library specified in makefile!\n");
coneOS_printf("ConeOS will return a wrong answer!\n");
}
#endif
/*
* exponential cone is not self dual, if s \in K
* then y \in K^* and so if K is the primal cone
* here we project onto K^*, via Moreau
*/
scaleArray(&(x[count]), -1, 3*k->ep); // x = -x;
double r,s,t;
int idx;
#pragma omp parallel for private(r,s,t,idx)
for (i=0; i < k->ep; ++i) {
idx = count + 3*i;
r = x[idx];
s = x[idx+1];
t = x[idx+2];
projExpCone(&(x[idx]));
x[idx] -= r;
x[idx+1] -= s;
x[idx+2] -= t;
}
count += 3*k->ep;
// exponential cone:
#pragma omp parallel for
for (i=0; i < k->ed; ++i) {
projExpCone(&(x[count + 3*i]));
}
count += 3*k->ed;
/* project onto OTHER cones */
}
double expNewtonOneD(double rho, double y_hat, double z_hat) {
double t = fmax( -z_hat , 1e-6);
double f, fp;
for (int i=0; i<100; ++i){
f = t * (t + z_hat) / rho / rho - y_hat/rho + log(t/rho) + 1;
fp = (2 * t + z_hat) / rho / rho + 1/t;
t = t - f/fp;
if (t <= -z_hat) {
return 0;
} else if (t <= 0) {
return z_hat;
} else if ( fabs(f) < 1e-9 ) {
break;
}
}
return t + z_hat;
}
void expSolveForXWithRho(double * v, double * x, double rho) {
x[2] = expNewtonOneD(rho, v[1], v[2]);
x[1] = (x[2] - v[2]) * x[2] / rho;
x[0] = v[0] - rho;
}
double expCalcGrad(double * v, double * x, double rho) {
expSolveForXWithRho(v, x, rho);
if (x[1] <= 1e-12) {
return x[0];
} else {
return x[0] + x[1] * log( x[1] / x[2] );
}
}
void expGetRhoUb(double * v, double * x, double * ub, double * lb) {
*lb = 0;
*ub = 0.125;
while(expCalcGrad(v, x, *ub) > 0) {
*lb = *ub;
(*ub) *= 2;
}
}
// project onto the exponential cone, v has dimension *exactly* 3
void projExpCone(double * v) {
double r = v[0], s = v[1], t = v[2];
// v in cl(Kexp)
if( (s*exp(r/s) <= t && s > 0) || (r <= 0 && s == 0 && t >= 0) ) {
return;
}
// -v in Kexp^*
if ( (-r < 0 && r*exp(s/r) <= -exp(1)*t) || (-r == 0 && -s >= 0 && -t >= 0) ) {
memset(v, 0, 3*sizeof(double));
return;
}
// special case with analytical solution
if(r < 0 && s < 0) {
v[1] = 0.0;
v[2] = fmax(v[2],0);
return;
}
double ub, lb, rho, g, x[3];
expGetRhoUb(v, x, &ub, &lb);
for(int i = 0; i < 100; ++i){
rho = (ub + lb)/2;
g = expCalcGrad(v, x, rho);
if (g > 0) {
lb = rho;
} else{
ub = rho;
}
if (ub - lb < 1e-9) {
break;
}
}
v[0] = x[0];
v[1] = x[1];
v[2] = x[2];
}
#ifdef LAPACK_LIB_FOUND
void projectsdc(double *X, int n, Work * w)
{ /* project onto the positive semi-definite cone */
if (n == 1) {
if(X[0] < 0.0) X[0] = 0.0;
return;
}
int i, j, m=0;
double * Xs = w->Xs;
double * Z = w->Z;
double * e = w->e;
memcpy(Xs,X,n*n*sizeof(double));
// Xs = X + X', save div by 2 for eigen-recomp
for (i = 0; i < n; ++i){
cblas_daxpy(n, 1, &(X[i]), n, &(Xs[i*n]), 1);
//b_daxpy(n, 1, &(X[i]), n, &(Xs[i*n]), 1);
}
double EIG_TOL = 1e-8;
double vupper = calcNorm(Xs,n*n);
LAPACKE_dsyevr( LAPACK_COL_MAJOR, 'V', 'V', 'U', n, Xs, n, 0.0, vupper, -1, -1, EIG_TOL, &m, e, Z, n , NULL);
//printf("m is %i, n is %i\n", m ,n);
//printf("vupper is %f, max eig is %f\n",vupper, e[m>0 ? m-1:0]/2);
memset(X, 0, n*n*sizeof(double));
for (i = 0; i < m; ++i) {
cblas_dsyr(CblasColMajor, CblasLower, n, e[i]/2, &(Z[i*n]), 1, X, n);
//b_dsyr('L', n, -e[i]/2, &(Z[i*n]), 1, Xs, n);
}
// fill in upper half
for (i = 0; i < n; ++i){
for (j = i+1; j < n; ++j){
X[i + j*n] = X[j + i*n];
}
}
}
#endif
|
cvxgrp/coneos
|
coneOSsparse/direct/private.c
|
#include "private.h"
// forward declare
int LDLInit(cs * A, int P[], double **info);
int LDLFactor(cs * A, int P[], int Pinv[], cs ** L, double **D);
void LDLSolve(double *x, double b[], cs * L, double D[], int P[], double * bp);
int factorize(Data * d,Work * w);
void freePriv(Work * w){
cs_spfree(w->p->L);coneOS_free(w->p->P);coneOS_free(w->p->D);coneOS_free(w->p->bp);
coneOS_free(w->p);
}
void solveLinSys(Data *d, Work * w, double * b, const double * s, int iter){
// returns solution to linear system
// Ax = b with solution stored in b
LDLSolve(b, b, w->p->L, w->p->D, w->p->P, w->p->bp);
}
int privateInitWork(Data * d, Work * w){
w->method = strdup("sparse-direct");
int n_plus_m = d->n + d->m;
w->p = coneOS_malloc(sizeof(Priv));
w->p->P = coneOS_malloc(sizeof(int)*n_plus_m);
w->p->L = coneOS_malloc(sizeof (cs));
w->p->bp = coneOS_malloc(n_plus_m * sizeof(double));
w->p->L->m = n_plus_m;
w->p->L->n = n_plus_m;
w->p->L->nz = -1;
return(factorize(d,w));
}
cs * formKKT(Data * d, Work * w){
/* ONLY UPPER TRIANGULAR PART IS STUFFED
* forms column compressed KKT matrix
* assumes column compressed form A matrix
*
* forms upper triangular part of [I A'; A -I]
*/
int j, k, kk;
/* I at top left */
const int Anz = d->Ap[d->n];
const int Knzmax = d->n + d->m + Anz;
cs * K = cs_spalloc(d->m + d->n, d->m + d->n, Knzmax, 1, 1);
if (!K)
{
return NULL;
}
kk = 0;
for (k = 0; k < d->n; k++){
K->i[kk] = k;
K->p[kk] = k;
K->x[kk] = d->RHO_X;
kk++;
}
/* A^T at top right : CCS: */
for (j = 0; j < d->n; j++) {
for (k = d->Ap[j]; k < d->Ap[j+1]; k++) {
K->p[kk] = d->Ai[k] + d->n;
K->i[kk] = j;
K->x[kk] = d->Ax[k];
kk++;
}
}
/* -I at bottom right */
for (k = 0; k < d->m; k++){
K->i[kk] = k + d->n;
K->p[kk] = k + d->n;
K->x[kk] = -1;
kk++;
}
// assert kk == Knzmax
K->nz = Knzmax;
cs * K_cs = cs_compress(K);
cs_spfree(K);
return(K_cs);
}
int factorize(Data * d,Work * w){
//tic();
cs * K = formKKT(d,w);
if (!K){
return -7; //arbitrary int
}
//if(d->VERBOSE) coneOS_printf("KKT matrix factorization info:\n");
double *info;
int amd_status = LDLInit(K, w->p->P, &info);
if (amd_status < 0) return(amd_status);
/*
if(d->VERBOSE) {
#ifdef DLONG
amd_l_info(info);
#else
amd_info(info);
#endif
}
*/
int * Pinv = cs_pinv(w->p->P, w->l-1);
cs * C = cs_symperm(K, Pinv, 1);
int ldl_status = LDLFactor(C, NULL, NULL, &w->p->L, &w->p->D);
//if(d->VERBOSE) coneOS_printf("KKT matrix factorization took %4.8f ms\n",tocq());
cs_spfree(C);cs_spfree(K);coneOS_free(Pinv);coneOS_free(info);
return(ldl_status);
}
int LDLInit(cs * A, int P[], double **info) {
*info = (double *) coneOS_malloc(AMD_INFO * sizeof(double));
#ifdef DLONG
return(amd_l_order(A->n, A->p, A->i, P, (double *) NULL, *info));
#else
return(amd_order(A->n, A->p, A->i, P, (double *) NULL, *info));
#endif
}
int LDLFactor(cs * A, int P[], int Pinv[], cs **L , double **D)
{
int n = A->n;
(*L)->p = (int *) coneOS_malloc((1 + n) * sizeof(int));
//int Parent[n], Lnz[n], Flag[n], Pattern[n];
//double Y[n];
int * Parent = coneOS_malloc(n*sizeof(int));
int * Lnz = coneOS_malloc(n*sizeof(int));
int * Flag = coneOS_malloc(n*sizeof(int));
int * Pattern = coneOS_malloc(n*sizeof(int));
double * Y = coneOS_malloc(n*sizeof(double));
ldl_symbolic(n, A->p, A->i, (*L)->p, Parent, Lnz, Flag, P, Pinv);
(*L)->nzmax = *((*L)->p + n);
(*L)->x = (double *) coneOS_malloc((*L)->nzmax * sizeof(double));
(*L)->i = (int *) coneOS_malloc((*L)->nzmax * sizeof(int));
*D = (double *) coneOS_malloc(n * sizeof(double));
if(!(*D) || !(*L)->i || !(*L)->x || !Y || !Pattern || !Flag || !Lnz || !Parent) return -1;
int kk = ldl_numeric(n, A->p, A->i, A->x, (*L)->p, Parent, Lnz, (*L)->i, (*L)->x, *D, Y, Pattern, Flag, P, Pinv);
coneOS_free(Parent);
coneOS_free(Lnz);
coneOS_free(Flag);
coneOS_free(Pattern);
coneOS_free(Y);
return(n - kk);
}
void LDLSolve(double *x, double b[], cs * L, double D[], int P[], double * bp)
{
// solves PLDL'P' x = b for x
int n = L->n;
if (P == NULL) {
if (x != b) // if they're different addresses
memcpy(x,b, n*sizeof(double));
ldl_lsolve(n, x, L->p, L->i, L->x);
ldl_dsolve(n, x, D);
ldl_ltsolve(n, x, L->p, L->i, L->x);
} else {
ldl_perm(n, bp, b, P);
ldl_lsolve(n, bp, L->p, L->i, L->x);
ldl_dsolve(n, bp, D);
ldl_ltsolve(n, bp, L->p, L->i, L->x);
ldl_permt(n, x, bp, P);
}
}
|
cvxgrp/coneos
|
coneOSdense/python/coneOSmodule.c
|
<reponame>cvxgrp/coneos
#include <Python.h>
#include "coneOS.h"
#include "numpy/arrayobject.h"
// TODO: when normalizing, make a copy
/* WARNING: this code uses numpy array types
*
* WARNING: this code also does not check that the data for the matrix A is
* actually column compressed storage for a sparse matrix. if it's not, the
* code will just crash inelegantly. support for cvxopt matrix or scipy sparse
* is planned, but not likely to be implemented soon.
*/
static PyObject *coneOSError;
static inline int getIntType() {
switch(NPY_SIZEOF_INT) {
case 1: return NPY_INT8;
case 2: return NPY_INT16;
case 4: return NPY_INT32;
case 8: return NPY_INT64;
default: return NPY_INT32; // defaults to 4 byte int
}
}
static inline int getDoubleType() {
return NPY_DOUBLE;
}
static inline void freeDataAndConeOnly(Data *d, Cone *k) {
// this function is useful since the Data and Cone "structs" do not own the
// memory for the arrays; numpy does.
if(d) free(d);
if(k) free(k);
d = NULL; k = NULL;
}
// TODO: use PyObject * to keep track of whether or not two objects are equivalent (for warm-starting)
// static const double *prev_Ax, *prev_b, *prev_c;
// static const int *prev_Ai, *prev_Ap, *prev_q;
static Sol *solution = NULL;
static void cleanup()
{
free_sol(solution);
}
static PyObject *solve(PyObject* self, PyObject *args, PyObject *keywords)
{
/* Expects a function call
* sol = solve(Ax, Ai, Ap, b, c, f=,l=,q=, MAX_ITERS=, EPS_ABS=, EPS_INFEAS=, ALPHA=, VERBOSE=, NORMALIZE=)
* The uppercase keywords are optional. If INDIRECT is #define'd, then
* CG_MAX_ITS and CG_TOL are also optional keyword arguments.
*
* "A" is a sparse matrix in column compressed storage. "Ax" are the values,
* "Ai" are the rows, and "Ap" are the column pointers.
* `Ax` is a Numpy array of doubles
* `Ai` is a Numpy array of ints
* `Ap` is a Numpy array of ints
*
* `b` is a (dense) Numpy array of doubles
* `c` is a (dense) Numpy array of doubles
*
* `f` is an integer giving the number of free variables
* `l` is an integer giving the number of nonnegative constraints
* `q` is a Numpy array of integers giving the number of cone constraints
*
*
* MAX_ITERS is an integer. Sets the maximum number of ADMM iterations.
* Defaults to 2000.
* EPS_ABS is a double. Sets the quitting tolerance for ADMM.
* Defaults to 1e-4.
* EPS_INFEAS is a double. Sets the quitting tolerance for infeasibility.
* Defaults to 5e-5.
* ALPHA is a double in (0,2) (non-inclusive). Sets the over-relaxation
* parameter. Defaults to 1.0.
* VERBOSE is an integer (or Boolean) either 0 or 1. Sets the verbosity of
* the solver. Defaults to 1 (or True).
* NORMALIZE is an integer (or Boolean) either 0 or 1. Tells the solver to
* normalize the data. Defaults to 0 (or False).
*
* CG_MAX_ITS is an integer. Sets the maximum number of CG iterations.
* Defaults to 20.
* CG_TOL is a double. Sets the tolerance for CG.
* Defaults to 1e-3.
*
* The code returns a Python dictionary with three keys, 'x', 'y', and 'status'.
* These report the primal and dual solution (as numpy arrays) and the solver
* status (as a string).
*/
#ifdef INDIRECT
static char *kwlist[] = {"Ax","Ai","Ap","b","c","f","l","q","MAX_ITERS", "EPS_ABS", "EPS_INFEAS", "ALPHA", "CG_MAX_ITS", "CG_TOL", "VERBOSE", "NORMALIZE", NULL};
#else
static char *kwlist[] = {"Ax","Ai","Ap","b","c","f","l","q","MAX_ITERS", "EPS_ABS", "EPS_INFEAS", "ALPHA", "VERBOSE", "NORMALIZE", NULL};
#endif
Data *d = calloc(1,sizeof(Data)); // sets everything to 0
Cone *k = calloc(1,sizeof(Cone)); // sets everything to 0
d->MAX_ITERS = 2000;
d->EPS_ABS = 1e-4;
d->EPS_INFEAS = 5e-5;
d->ALPH = 1.0;
d->VERBOSE = 1;
#ifdef INDIRECT
d->CG_MAX_ITS = 20;
d->CG_TOL = 1e-3;
#endif
PyArrayObject *Ax, *Ai, *Ap, *b, *c, *q = NULL;
PyArrayObject *tmp_arr;
PyArrayObject *Ax_arr, *Ai_arr, *Ap_arr, *b_arr, *c_arr, *q_arr = NULL;
int intType = getIntType();
int doubleType = getDoubleType();
#ifdef INDIRECT
if( !PyArg_ParseTupleAndKeywords(args, keywords, "O!O!O!O!O!|iiO!idddidii", kwlist,
&PyArray_Type, &Ax,
&PyArray_Type, &Ai,
&PyArray_Type, &Ap,
&PyArray_Type, &b,
&PyArray_Type, &c,
&(k->f),
&(k->l),
&PyArray_Type, &q,
&(d->MAX_ITERS),
&(d->EPS_ABS),
&(d->EPS_INFEAS),
&(d->ALPH),
&(d->CG_MAX_ITS),
&(d->CG_TOL),
&(d->VERBOSE),
&(d->NORMALIZE))
) { freeDataAndConeOnly(d,k); return NULL; }
#else
if( !PyArg_ParseTupleAndKeywords(args, keywords, "O!O!O!O!O!|iiO!idddii", kwlist,
&PyArray_Type, &Ax,
&PyArray_Type, &Ai,
&PyArray_Type, &Ap,
&PyArray_Type, &b,
&PyArray_Type, &c,
&(k->f),
&(k->l),
&PyArray_Type, &q,
&(d->MAX_ITERS),
&(d->EPS_ABS),
&(d->EPS_INFEAS),
&(d->ALPH),
&(d->VERBOSE),
&(d->NORMALIZE))
) { freeDataAndConeOnly(d,k); return NULL; }
#endif
// check that Ax is a double array (and ensure it's of type "double")
if( !PyArray_ISFLOAT(Ax) ) {
PyErr_SetString(coneOSError, "Ax must be a numpy array of floats");
freeDataAndConeOnly(d,k);
return NULL;
}
tmp_arr = PyArray_GETCONTIGUOUS(Ax);
Ax_arr = (PyArrayObject *) PyArray_Cast(tmp_arr, doubleType);
Py_DECREF(tmp_arr);
d->Ax = (double *) PyArray_DATA(Ax_arr);
// check that Ai is a int array (and ensure it's of type "int")
if( !PyArray_ISINTEGER(Ai) ) {
PyErr_SetString(coneOSError, "Ai must be a numpy array of ints");
Py_DECREF(Ax_arr);
freeDataAndConeOnly(d,k);
return NULL;
}
tmp_arr = PyArray_GETCONTIGUOUS(Ai);
Ai_arr = (PyArrayObject *) PyArray_Cast(tmp_arr, intType);
Py_DECREF(tmp_arr);
d->Ai = (int *) PyArray_DATA(Ai_arr);
// check that Ap is a int array (and ensure it's of type "int")
if( !PyArray_ISINTEGER(Ap) ) {
PyErr_SetString(coneOSError, "Ap must be a numpy array of ints");
Py_DECREF(Ax_arr); Py_DECREF(Ai_arr);
freeDataAndConeOnly(d,k);
return NULL;
}
tmp_arr = PyArray_GETCONTIGUOUS(Ap);
Ap_arr = (PyArrayObject *) PyArray_Cast(tmp_arr, intType);
Py_DECREF(tmp_arr);
d->Ap = (int *) PyArray_DATA(Ap_arr);
// check that b is a double array (and ensure it's of type "double")
if( !PyArray_ISFLOAT(b) ) {
PyErr_SetString(coneOSError, "b must be a numpy array of floats");
Py_DECREF(Ax_arr); Py_DECREF(Ai_arr); Py_DECREF(Ap_arr);
freeDataAndConeOnly(d,k);
return NULL;
}
tmp_arr = PyArray_GETCONTIGUOUS(b);
b_arr = (PyArrayObject *) PyArray_Cast(tmp_arr, doubleType);
Py_DECREF(tmp_arr);
d->b = (double *) PyArray_DATA(b_arr);
d->m = (int) PyArray_SIZE(b_arr); // loses precision
// check that c is a double array (and ensure it's of type "double")
if( !PyArray_ISFLOAT(c) ) {
PyErr_SetString(coneOSError, "c must be a numpy array of floats");
Py_DECREF(Ax_arr); Py_DECREF(Ai_arr); Py_DECREF(Ap_arr); Py_DECREF(b_arr);
freeDataAndConeOnly(d,k);
return NULL;
}
tmp_arr = PyArray_GETCONTIGUOUS(c);
c_arr = (PyArrayObject *) PyArray_Cast(tmp_arr, doubleType);
Py_DECREF(tmp_arr);
d->c = (double *) PyArray_DATA(c_arr);
d->n = (int) PyArray_SIZE(c_arr); // loses precision
// check that q is a int array (and ensure it's of type "double")
if(q) {
if( !PyArray_ISINTEGER(q) ) {
PyErr_SetString(coneOSError, "q must be a numpy array of ints");
Py_DECREF(Ax_arr); Py_DECREF(Ai_arr); Py_DECREF(Ap_arr); Py_DECREF(b_arr); Py_DECREF(c_arr);
freeDataAndConeOnly(d,k);
return NULL;
}
tmp_arr = PyArray_GETCONTIGUOUS(q);
q_arr = (PyArrayObject *) PyArray_Cast(tmp_arr, intType);
Py_DECREF(tmp_arr);
k->q = (int *) PyArray_DATA(q_arr);
k->qsize = (int) PyArray_SIZE(q_arr); // loses precision
}
// TODO: check that parameter values are correct
// solve the problem
// TODO: preserve the workspace
solution = coneOS(d, k);
npy_intp dims[1];
dims[0] = d->n;
PyObject *primalSol = PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, solution->x);
dims[0] = d->m;
PyObject *dualSol = PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, solution->y);
PyObject *returnDict = Py_BuildValue("{s:O,s:O,s:s}","x", primalSol, "y", dualSol, "status", solution->status);
// give up ownership to the return dictionary
Py_DECREF(primalSol); Py_DECREF(dualSol);
// do some cleanup
freeDataAndConeOnly(d,k);
Py_DECREF(Ax_arr); Py_DECREF(Ai_arr); Py_DECREF(Ap_arr); Py_DECREF(b_arr); Py_DECREF(c_arr);
if(q_arr)
Py_DECREF(q_arr);
return returnDict;
}
static PyMethodDef coneOSMethods[] =
{
{"solve", (PyCFunction)solve, METH_VARARGS | METH_KEYWORDS,
"Solve a conic optimization problem."},
{NULL, NULL, 0, NULL} // sentinel
};
PyMODINIT_FUNC
#ifdef INDIRECT
initconeOS_indirect(void)
#else
initconeOS_direct(void)
#endif
{
PyObject *m;
#ifdef INDIRECT
m = Py_InitModule("coneOS_indirect", coneOSMethods);
#else
m = Py_InitModule("coneOS_direct", coneOSMethods);
#endif
import_array(); // for numpy support
if(m == NULL)
return;
#ifdef INDIRECT
coneOSError = PyErr_NewException("coneOS_indirect.error", NULL, NULL);
#else
coneOSError = PyErr_NewException("coneOS_direct.error", NULL, NULL);
#endif
Py_INCREF(coneOSError);
PyModule_AddObject(m, "error", coneOSError);
Py_AtExit(&cleanup);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.