function varargout = conic(varargin)
    %CONIC Create a QP solver Solves the following strictly convex problem:
    %
    %  Function = CONIC(char name, char solver, struct:Sparsity qp, struct opts)
    %
    %
    %
    %
    %::
    %
    %  min          1/2 x' H x + g' x
    %  x
    %  
    %  subject to
    %  LBA <= A x <= UBA
    %  LBX <= x   <= UBX
    %  
    %  with :
    %  H sparse (n x n) positive definite
    %  g dense  (n x 1)
    %  
    %  n: number of decision variables (x)
    %  nc: number of constraints (A)
    %
    %
    %
    %If H is not positive-definite, the solver should throw an error.
    %
    %General information
    %===================
    %
    %
    %
    %>List of available options
    %
    %+-----------------+-----------------+-----------------+-----------------+
    %|       Id        |      Type       |   Description   |     Used in     |
    %+=================+=================+=================+=================+
    %| ad_weight       | OT_DOUBLE       | Weighting       | casadi::Functio |
    %|                 |                 | factor for      | nInternal       |
    %|                 |                 | derivative calc |                 |
    %|                 |                 | ulation.When    |                 |
    %|                 |                 | there is an     |                 |
    %|                 |                 | option of       |                 |
    %|                 |                 | either using    |                 |
    %|                 |                 | forward or      |                 |
    %|                 |                 | reverse mode    |                 |
    %|                 |                 | directional     |                 |
    %|                 |                 | derivatives,    |                 |
    %|                 |                 | the condition a |                 |
    %|                 |                 | d_weight*nf<=(1 |                 |
    %|                 |                 | -ad_weight)*na  |                 |
    %|                 |                 | is used where   |                 |
    %|                 |                 | nf and na are   |                 |
    %|                 |                 | estimates of    |                 |
    %|                 |                 | the number of   |                 |
    %|                 |                 | forward/reverse |                 |
    %|                 |                 | mode            |                 |
    %|                 |                 | directional     |                 |
    %|                 |                 | derivatives     |                 |
    %|                 |                 | needed. By      |                 |
    %|                 |                 | default,        |                 |
    %|                 |                 | ad_weight is    |                 |
    %|                 |                 | calculated      |                 |
    %|                 |                 | automatically,  |                 |
    %|                 |                 | but this can be |                 |
    %|                 |                 | overridden by   |                 |
    %|                 |                 | setting this    |                 |
    %|                 |                 | option. In      |                 |
    %|                 |                 | particular, 0   |                 |
    %|                 |                 | means forcing   |                 |
    %|                 |                 | forward mode    |                 |
    %|                 |                 | and 1 forcing   |                 |
    %|                 |                 | reverse mode.   |                 |
    %|                 |                 | Leave unset for |                 |
    %|                 |                 | (class          |                 |
    %|                 |                 | specific)       |                 |
    %|                 |                 | heuristics.     |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| ad_weight_sp    | OT_DOUBLE       | Weighting       | casadi::Functio |
    %|                 |                 | factor for      | nInternal       |
    %|                 |                 | sparsity        |                 |
    %|                 |                 | pattern         |                 |
    %|                 |                 | calculation cal |                 |
    %|                 |                 | culation.Overri |                 |
    %|                 |                 | des default     |                 |
    %|                 |                 | behavior. Set   |                 |
    %|                 |                 | to 0 and 1 to   |                 |
    %|                 |                 | force forward   |                 |
    %|                 |                 | and reverse     |                 |
    %|                 |                 | mode            |                 |
    %|                 |                 | respectively.   |                 |
    %|                 |                 | Cf. option      |                 |
    %|                 |                 | "ad_weight".    |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| compiler        | OT_STRING       | Just-in-time    | casadi::Functio |
    %|                 |                 | compiler plugin | nInternal       |
    %|                 |                 | to be used.     |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| derivative_of   | OT_FUNCTION     | The function is | casadi::Functio |
    %|                 |                 | a derivative of | nInternal       |
    %|                 |                 | another         |                 |
    %|                 |                 | function. The   |                 |
    %|                 |                 | type of         |                 |
    %|                 |                 | derivative      |                 |
    %|                 |                 | (directional    |                 |
    %|                 |                 | derivative,     |                 |
    %|                 |                 | Jacobian) is    |                 |
    %|                 |                 | inferred from   |                 |
    %|                 |                 | the function    |                 |
    %|                 |                 | name.           |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| discrete        | OT_BOOLVECTOR   | Indicates which | casadi::Conic   |
    %|                 |                 | of the          |                 |
    %|                 |                 | variables are   |                 |
    %|                 |                 | discrete, i.e.  |                 |
    %|                 |                 | integer-valued  |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| gather_stats    | OT_BOOL         | Deprecated      | casadi::Functio |
    %|                 |                 | option          | nInternal       |
    %|                 |                 | (ignored):      |                 |
    %|                 |                 | Statistics are  |                 |
    %|                 |                 | now always      |                 |
    %|                 |                 | collected.      |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| input_scheme    | OT_STRINGVECTOR | Custom input    | casadi::Functio |
    %|                 |                 | scheme          | nInternal       |
    %+-----------------+-----------------+-----------------+-----------------+
    %| inputs_check    | OT_BOOL         | Throw           | casadi::Functio |
    %|                 |                 | exceptions when | nInternal       |
    %|                 |                 | the numerical   |                 |
    %|                 |                 | values of the   |                 |
    %|                 |                 | inputs don't    |                 |
    %|                 |                 | make sense      |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| jac_penalty     | OT_DOUBLE       | When requested  | casadi::Functio |
    %|                 |                 | for a number of | nInternal       |
    %|                 |                 | forward/reverse |                 |
    %|                 |                 | directions, it  |                 |
    %|                 |                 | may be cheaper  |                 |
    %|                 |                 | to compute      |                 |
    %|                 |                 | first the full  |                 |
    %|                 |                 | jacobian and    |                 |
    %|                 |                 | then multiply   |                 |
    %|                 |                 | with seeds,     |                 |
    %|                 |                 | rather than     |                 |
    %|                 |                 | obtain the      |                 |
    %|                 |                 | requested       |                 |
    %|                 |                 | directions in a |                 |
    %|                 |                 | straightforward |                 |
    %|                 |                 | manner. Casadi  |                 |
    %|                 |                 | uses a          |                 |
    %|                 |                 | heuristic to    |                 |
    %|                 |                 | decide which is |                 |
    %|                 |                 | cheaper. A high |                 |
    %|                 |                 | value of        |                 |
    %|                 |                 | 'jac_penalty'   |                 |
    %|                 |                 | makes it less   |                 |
    %|                 |                 | likely for the  |                 |
    %|                 |                 | heurstic to     |                 |
    %|                 |                 | chose the full  |                 |
    %|                 |                 | Jacobian        |                 |
    %|                 |                 | strategy. The   |                 |
    %|                 |                 | special value   |                 |
    %|                 |                 | -1 indicates    |                 |
    %|                 |                 | never to use    |                 |
    %|                 |                 | the full        |                 |
    %|                 |                 | Jacobian        |                 |
    %|                 |                 | strategy        |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| jit             | OT_BOOL         | Use just-in-    | casadi::Functio |
    %|                 |                 | time compiler   | nInternal       |
    %|                 |                 | to speed up the |                 |
    %|                 |                 | evaluation      |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| jit_options     | OT_DICT         | Options to be   | casadi::Functio |
    %|                 |                 | passed to the   | nInternal       |
    %|                 |                 | jit compiler.   |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| output_scheme   | OT_STRINGVECTOR | Custom output   | casadi::Functio |
    %|                 |                 | scheme          | nInternal       |
    %+-----------------+-----------------+-----------------+-----------------+
    %| regularity_chec | OT_BOOL         | Throw           | casadi::Functio |
    %| k               |                 | exceptions when | nInternal       |
    %|                 |                 | NaN or Inf      |                 |
    %|                 |                 | appears during  |                 |
    %|                 |                 | evaluation      |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| user_data       | OT_VOIDPTR      | A user-defined  | casadi::Functio |
    %|                 |                 | field that can  | nInternal       |
    %|                 |                 | be used to      |                 |
    %|                 |                 | identify the    |                 |
    %|                 |                 | function or     |                 |
    %|                 |                 | pass additional |                 |
    %|                 |                 | information     |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %| verbose         | OT_BOOL         | Verbose         | casadi::Functio |
    %|                 |                 | evaluation  for | nInternal       |
    %|                 |                 | debugging       |                 |
    %+-----------------+-----------------+-----------------+-----------------+
    %
    %>Input scheme: casadi::ConicInput (CONIC_NUM_IN = 9) []
    %
    %+------------------------+------------------------+------------------------+
    %|       Full name        |         Short          |      Description       |
    %+========================+========================+========================+
    %| CONIC_H                |                        | The square matrix H:   |
    %|                        |                        | sparse, (n x n). Only  |
    %|                        |                        | the lower triangular   |
    %|                        |                        | part is actually used. |
    %|                        |                        | The matrix is assumed  |
    %|                        |                        | to be symmetrical.     |
    %+------------------------+------------------------+------------------------+
    %| CONIC_G                |                        | The vector g: dense,   |
    %|                        |                        | (n x 1)                |
    %+------------------------+------------------------+------------------------+
    %| CONIC_A                |                        | The matrix A: sparse,  |
    %|                        |                        | (nc x n) - product     |
    %|                        |                        | with x must be dense.  |
    %+------------------------+------------------------+------------------------+
    %| CONIC_LBA              |                        | dense, (nc x 1)        |
    %+------------------------+------------------------+------------------------+
    %| CONIC_UBA              |                        | dense, (nc x 1)        |
    %+------------------------+------------------------+------------------------+
    %| CONIC_LBX              |                        | dense, (n x 1)         |
    %+------------------------+------------------------+------------------------+
    %| CONIC_UBX              |                        | dense, (n x 1)         |
    %+------------------------+------------------------+------------------------+
    %| CONIC_X0               |                        | dense, (n x 1)         |
    %+------------------------+------------------------+------------------------+
    %| CONIC_LAM_X0           |                        | dense                  |
    %+------------------------+------------------------+------------------------+
    %
    %>Output scheme: casadi::ConicOutput (CONIC_NUM_OUT = 4) []
    %
    %+-------------+-------+---------------------------------------------------+
    %|  Full name  | Short |                    Description                    |
    %+=============+=======+===================================================+
    %| CONIC_X     |       | The primal solution.                              |
    %+-------------+-------+---------------------------------------------------+
    %| CONIC_COST  |       | The optimal cost.                                 |
    %+-------------+-------+---------------------------------------------------+
    %| CONIC_LAM_A |       | The dual solution corresponding to linear bounds. |
    %+-------------+-------+---------------------------------------------------+
    %| CONIC_LAM_X |       | The dual solution corresponding to simple bounds. |
    %+-------------+-------+---------------------------------------------------+
    %
    %List of plugins
    %===============
    %
    %
    %
    %- clp
    %
    %- cplex
    %
    %- gurobi
    %
    %- ooqp
    %
    %- qpoases
    %
    %- sqic
    %
    %- nlpsol
    %
    %Note: some of the plugins in this list might not be available on your
    %system. Also, there might be extra plugins available to you that are not
    %listed here. You can obtain their documentation with
    %Conic.doc("myextraplugin")
    %
    %
    %
    %--------------------------------------------------------------------------------
    %
    %clp
    %---
    %
    %
    %
    %Interface to Clp solver for sparse Quadratic Programs
    %
    %--------------------------------------------------------------------------------
    %
    %
    %
    %
    %
    %--------------------------------------------------------------------------------
    %
    %cplex
    %-----
    %
    %
    %
    %Interface to Cplex solver for sparse Quadratic Programs
    %
    %>List of available options
    %
    %+------------------------+------------------------+------------------------+
    %|           Id           |          Type          |      Description       |
    %+========================+========================+========================+
    %| cplex                  | OT_DICT                | Options to be passed   |
    %|                        |                        | to CPLEX               |
    %+------------------------+------------------------+------------------------+
    %| dep_check              | OT_INT                 | Detect redundant       |
    %|                        |                        | constraints.           |
    %+------------------------+------------------------+------------------------+
    %| dump_filename          | OT_STRING              | The filename to dump   |
    %|                        |                        | to.                    |
    %+------------------------+------------------------+------------------------+
    %| dump_to_file           | OT_BOOL                | Dumps QP to file in    |
    %|                        |                        | CPLEX format.          |
    %+------------------------+------------------------+------------------------+
    %| qp_method              | OT_INT                 | Determines which CPLEX |
    %|                        |                        | algorithm to use.      |
    %+------------------------+------------------------+------------------------+
    %| tol                    | OT_DOUBLE              | Tolerance of solver    |
    %+------------------------+------------------------+------------------------+
    %| warm_start             | OT_BOOL                | Use warm start with    |
    %|                        |                        | simplex methods        |
    %|                        |                        | (affects only the      |
    %|                        |                        | simplex methods).      |
    %+------------------------+------------------------+------------------------+
    %
    %--------------------------------------------------------------------------------
    %
    %
    %
    %--------------------------------------------------------------------------------
    %
    %gurobi
    %------
    %
    %
    %
    %Interface to the GUROBI Solver for quadratic programming
    %
    %>List of available options
    %
    %+------------------------+------------------------+------------------------+
    %|           Id           |          Type          |      Description       |
    %+========================+========================+========================+
    %| vtype                  | OT_STRINGVECTOR        | Type of variables: [CO |
    %|                        |                        | NTINUOUS|binary|intege |
    %|                        |                        | r|semicont|semiint]    |
    %+------------------------+------------------------+------------------------+
    %
    %--------------------------------------------------------------------------------
    %
    %
    %
    %--------------------------------------------------------------------------------
    %
    %ooqp
    %----
    %
    %
    %
    %Interface to the OOQP Solver for quadratic programming The current
    %implementation assumes that OOQP is configured with the MA27 sparse linear
    %solver.
    %
    %NOTE: when doing multiple calls to evaluate(), check if you need to
    %reInit();
    %
    %>List of available options
    %
    %+------------------------+------------------------+------------------------+
    %|           Id           |          Type          |      Description       |
    %+========================+========================+========================+
    %| artol                  | OT_DOUBLE              | tolerance as provided  |
    %|                        |                        | with setArTol to OOQP  |
    %+------------------------+------------------------+------------------------+
    %| mutol                  | OT_DOUBLE              | tolerance as provided  |
    %|                        |                        | with setMuTol to OOQP  |
    %+------------------------+------------------------+------------------------+
    %| print_level            | OT_INT                 | Print level. OOQP      |
    %|                        |                        | listens to print_level |
    %|                        |                        | 0, 10 and 100          |
    %+------------------------+------------------------+------------------------+
    %
    %--------------------------------------------------------------------------------
    %
    %
    %
    %--------------------------------------------------------------------------------
    %
    %qpoases
    %-------
    %
    %
    %
    %Interface to QPOases Solver for quadratic programming
    %
    %>List of available options
    %
    %+------------------------+------------------------+------------------------+
    %|           Id           |          Type          |      Description       |
    %+========================+========================+========================+
    %| CPUtime                | OT_DOUBLE              | The maximum allowed    |
    %|                        |                        | CPU time in seconds    |
    %|                        |                        | for the whole          |
    %|                        |                        | initialisation (and    |
    %|                        |                        | the actually required  |
    %|                        |                        | one on output).        |
    %|                        |                        | Disabled if unset.     |
    %+------------------------+------------------------+------------------------+
    %| boundRelaxation        | OT_DOUBLE              | Initial relaxation of  |
    %|                        |                        | bounds to start        |
    %|                        |                        | homotopy and initial   |
    %|                        |                        | value for far bounds.  |
    %+------------------------+------------------------+------------------------+
    %| boundTolerance         | OT_DOUBLE              | If upper and lower     |
    %|                        |                        | bounds differ less     |
    %|                        |                        | than this tolerance,   |
    %|                        |                        | they are regarded      |
    %|                        |                        | equal, i.e. as         |
    %|                        |                        | equality constraint.   |
    %+------------------------+------------------------+------------------------+
    %| enableCholeskyRefactor | OT_INT                 | Specifies the          |
    %| isation                |                        | frequency of a full    |
    %|                        |                        | re-factorisation of    |
    %|                        |                        | projected Hessian      |
    %|                        |                        | matrix: 0: turns them  |
    %|                        |                        | off, 1: uses them at   |
    %|                        |                        | each iteration etc.    |
    %+------------------------+------------------------+------------------------+
    %| enableDriftCorrection  | OT_INT                 | Specifies the          |
    %|                        |                        | frequency of drift     |
    %|                        |                        | corrections: 0: turns  |
    %|                        |                        | them off.              |
    %+------------------------+------------------------+------------------------+
    %| enableEqualities       | OT_BOOL                | Specifies whether      |
    %|                        |                        | equalities should be   |
    %|                        |                        | treated as always      |
    %|                        |                        | active (True) or not   |
    %|                        |                        | (False)                |
    %+------------------------+------------------------+------------------------+
    %| enableFarBounds        | OT_BOOL                | Enables the use of far |
    %|                        |                        | bounds.                |
    %+------------------------+------------------------+------------------------+
    %| enableFlippingBounds   | OT_BOOL                | Enables the use of     |
    %|                        |                        | flipping bounds.       |
    %+------------------------+------------------------+------------------------+
    %| enableFullLITests      | OT_BOOL                | Enables condition-     |
    %|                        |                        | hardened (but more     |
    %|                        |                        | expensive) LI test.    |
    %+------------------------+------------------------+------------------------+
    %| enableInertiaCorrectio | OT_BOOL                | Should working set be  |
    %| n                      |                        | repaired when negative |
    %|                        |                        | curvature is           |
    %|                        |                        | discovered during      |
    %|                        |                        | hotstart.              |
    %+------------------------+------------------------+------------------------+
    %| enableNZCTests         | OT_BOOL                | Enables nonzero        |
    %|                        |                        | curvature tests.       |
    %+------------------------+------------------------+------------------------+
    %| enableRamping          | OT_BOOL                | Enables ramping.       |
    %+------------------------+------------------------+------------------------+
    %| enableRegularisation   | OT_BOOL                | Enables automatic      |
    %|                        |                        | Hessian                |
    %|                        |                        | regularisation.        |
    %+------------------------+------------------------+------------------------+
    %| epsDen                 | OT_DOUBLE              | Denominator tolerance  |
    %|                        |                        | for ratio tests.       |
    %+------------------------+------------------------+------------------------+
    %| epsFlipping            | OT_DOUBLE              | Tolerance of squared   |
    %|                        |                        | Cholesky diagonal      |
    %|                        |                        | factor which triggers  |
    %|                        |                        | flipping bound.        |
    %+------------------------+------------------------+------------------------+
    %| epsIterRef             | OT_DOUBLE              | Early termination      |
    %|                        |                        | tolerance for          |
    %|                        |                        | iterative refinement.  |
    %+------------------------+------------------------+------------------------+
    %| epsLITests             | OT_DOUBLE              | Tolerance for linear   |
    %|                        |                        | independence tests.    |
    %+------------------------+------------------------+------------------------+
    %| epsNZCTests            | OT_DOUBLE              | Tolerance for nonzero  |
    %|                        |                        | curvature tests.       |
    %+------------------------+------------------------+------------------------+
    %| epsNum                 | OT_DOUBLE              | Numerator tolerance    |
    %|                        |                        | for ratio tests.       |
    %+------------------------+------------------------+------------------------+
    %| epsRegularisation      | OT_DOUBLE              | Scaling factor of      |
    %|                        |                        | identity matrix used   |
    %|                        |                        | for Hessian            |
    %|                        |                        | regularisation.        |
    %+------------------------+------------------------+------------------------+
    %| finalRamping           | OT_DOUBLE              | Final value for        |
    %|                        |                        | ramping strategy.      |
    %+------------------------+------------------------+------------------------+
    %| growFarBounds          | OT_DOUBLE              | Factor to grow far     |
    %|                        |                        | bounds.                |
    %+------------------------+------------------------+------------------------+
    %| hessian_type           | OT_STRING              | Type of Hessian - see  |
    %|                        |                        | qpOASES documentation  |
    %|                        |                        | [UNKNOWN|posdef|semide |
    %|                        |                        | f|indef|zero|identity] |
    %|                        |                        | ]                      |
    %+------------------------+------------------------+------------------------+
    %| initialFarBounds       | OT_DOUBLE              | Initial size for far   |
    %|                        |                        | bounds.                |
    %+------------------------+------------------------+------------------------+
    %| initialRamping         | OT_DOUBLE              | Start value for        |
    %|                        |                        | ramping strategy.      |
    %+------------------------+------------------------+------------------------+
    %| initialStatusBounds    | OT_STRING              | Initial status of      |
    %|                        |                        | bounds at first        |
    %|                        |                        | iteration.             |
    %+------------------------+------------------------+------------------------+
    %| linsol_plugin          | OT_STRING              | Linear solver plugin   |
    %+------------------------+------------------------+------------------------+
    %| maxDualJump            | OT_DOUBLE              | Maximum allowed jump   |
    %|                        |                        | in dual variables in   |
    %|                        |                        | linear independence    |
    %|                        |                        | tests.                 |
    %+------------------------+------------------------+------------------------+
    %| maxPrimalJump          | OT_DOUBLE              | Maximum allowed jump   |
    %|                        |                        | in primal variables in |
    %|                        |                        | nonzero curvature      |
    %|                        |                        | tests.                 |
    %+------------------------+------------------------+------------------------+
    %| max_schur              | OT_INT                 | Maximal number of      |
    %|                        |                        | Schur updates [75]     |
    %+------------------------+------------------------+------------------------+
    %| nWSR                   | OT_INT                 | The maximum number of  |
    %|                        |                        | working set            |
    %|                        |                        | recalculations to be   |
    %|                        |                        | performed during the   |
    %|                        |                        | initial homotopy.      |
    %|                        |                        | Default is 5(nx + nc)  |
    %+------------------------+------------------------+------------------------+
    %| numRefinementSteps     | OT_INT                 | Maximum number of      |
    %|                        |                        | iterative refinement   |
    %|                        |                        | steps.                 |
    %+------------------------+------------------------+------------------------+
    %| numRegularisationSteps | OT_INT                 | Maximum number of      |
    %|                        |                        | successive             |
    %|                        |                        | regularisation steps.  |
    %+------------------------+------------------------+------------------------+
    %| printLevel             | OT_STRING              | Defines the amount of  |
    %|                        |                        | text output during QP  |
    %|                        |                        | solution, see Section  |
    %|                        |                        | 5.7                    |
    %+------------------------+------------------------+------------------------+
    %| schur                  | OT_BOOL                | Use Schur Complement   |
    %|                        |                        | Approach [false]       |
    %+------------------------+------------------------+------------------------+
    %| sparse                 | OT_BOOL                | Formulate the QP using |
    %|                        |                        | sparse matrices.       |
    %|                        |                        | [false]                |
    %+------------------------+------------------------+------------------------+
    %| terminationTolerance   | OT_DOUBLE              | Relative termination   |
    %|                        |                        | tolerance to stop      |
    %|                        |                        | homotopy.              |
    %+------------------------+------------------------+------------------------+
    %
    %--------------------------------------------------------------------------------
    %
    %
    %
    %--------------------------------------------------------------------------------
    %
    %sqic
    %----
    %
    %
    %
    %Interface to the SQIC solver for quadratic programming
    %
    %--------------------------------------------------------------------------------
    %
    %
    %
    %
    %
    %--------------------------------------------------------------------------------
    %
    %nlpsol
    %------
    %
    %
    %
    %Solve QPs using an Nlpsol Use the 'nlpsol' option to specify the NLP solver
    %to use.
    %
    %>List of available options
    %
    %+----------------+-----------+---------------------------------+
    %|       Id       |   Type    |           Description           |
    %+================+===========+=================================+
    %| nlpsol         | OT_STRING | Name of solver.                 |
    %+----------------+-----------+---------------------------------+
    %| nlpsol_options | OT_DICT   | Options to be passed to solver. |
    %+----------------+-----------+---------------------------------+
    %
    %--------------------------------------------------------------------------------
    %
    %
    %
    %Joel Andersson
    %
    %
    %
  [varargout{1:nargout}] = casadiMEX(851, varargin{:});
end
