20671 warnings generated.
./backends/base_backend.hpp:65:3: warning: use '= default' to define a trivial destructor [modernize-use-default]
  virtual ~BaseBackend() {};
  ^
                         = default;
./backends/base_backend.hpp:181:15: warning: statement should be inside braces [readability-braces-around-statements]
    if (n > 0)
              ^
./backends/base_backend.hpp:185:15: warning: statement should be inside braces [readability-braces-around-statements]
    if (n > 0)
              ^
./backends/base_backend.hpp:285:41: warning: statement should be inside braces [readability-braces-around-statements]
  for (const auto &op : prog.operations)
                                        ^
./backends/base_backend.hpp:286:58: warning: statement should be inside braces [readability-braces-around-statements]
    if (!op.if_op || (op.if_op && qc_passed_if(op.cond)))
                                                         ^
./backends/base_backend.hpp:294:58: warning: statement should be inside braces [readability-braces-around-statements]
    if (!op.if_op || (op.if_op && qc_passed_if(op.cond)))
                                                         ^
./backends/base_backend.hpp:304:48: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (size_t j = 0; j < cond.mask.size(); j++)
                                               ^
./backends/base_backend.hpp:305:27: warning: statement should be inside braces [readability-braces-around-statements]
    if (cond.mask[j] == 1)
                          ^
./backends/base_backend.hpp:356:9: warning: statement should be inside braces [readability-braces-around-statements]
  } else
        ^
./backends/base_backend.hpp:386:5: warning: don't use else after return [readability-else-after-return]
  } else
    ^
./backends/base_backend.hpp:386:9: warning: statement should be inside braces [readability-braces-around-statements]
  } else
        ^
./backends/base_backend.hpp:400:5: warning: don't use else after return [readability-else-after-return]
  } else
    ^
./backends/base_backend.hpp:400:9: warning: statement should be inside braces [readability-braces-around-statements]
  } else
        ^
./backends/clifford_backend.hpp:50:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override]
  void set_config(json_t &config);
       ^
                                  override
./backends/clifford_backend.hpp:51:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override]
  void initialize(const Circuit &prog);
       ^
                                       override
./backends/clifford_backend.hpp:52:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override]
  void qc_operation(const operation &op);
       ^
                                         override
./backends/clifford_backend.hpp:67:8: warning: function 'QISKIT::CliffordBackend::qc_measure' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void qc_measure(const uint_t qubit, const uint_t bit);
       ^
                                                   cbit
./backends/clifford_backend.hpp:247:23: note: the definition seen here
void CliffordBackend::qc_measure(const uint_t qubit, const uint_t cbit) {
                      ^
./backends/clifford_backend.hpp:67:8: note: differing parameters are named here: ('bit'), in definition: ('cbit')
  void qc_measure(const uint_t qubit, const uint_t bit);
       ^
./backends/clifford_backend.hpp:91:8: warning: function 'QISKIT::CliffordBackend::qc_u0' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void qc_u0(const uint_t qubit, const double m);
       ^
                                              n
./backends/clifford_backend.hpp:559:23: note: the definition seen here
void CliffordBackend::qc_u0(const uint_t qubit, const double n) {
                      ^
./backends/clifford_backend.hpp:91:8: note: differing parameters are named here: ('m'), in definition: ('n')
  void qc_u0(const uint_t qubit, const double m);
       ^
./backends/clifford_backend.hpp:93:8: warning: function 'QISKIT::CliffordBackend::qc_noise' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void qc_noise(const uint_t qubit_c, const uint_t qubit_t,
       ^
./backends/clifford_backend.hpp:527:23: note: the definition seen here
void CliffordBackend::qc_noise(const uint_t qubit_c, const uint_t qubit_t,
                      ^
./backends/clifford_backend.hpp:93:8: note: differing parameters are named here: ('gate'), in definition: ('err')
  void qc_noise(const uint_t qubit_c, const uint_t qubit_t,
       ^
./backends/clifford_backend.hpp:103:23: warning: function 'set_config' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::set_config(json_t &config) {
                      ^
inline 
./backends/clifford_backend.hpp:111:23: warning: function 'initialize' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::initialize(const Circuit &prog) {
                      ^
inline 
./backends/clifford_backend.hpp:121:42: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (qreg_init.size() == prog.nqubits)
                                         ^
./backends/clifford_backend.hpp:132:23: warning: function 'qc_operation' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_operation(const operation &op) {
                      ^
inline 
./backends/clifford_backend.hpp:180:20: warning: statement should be inside braces [readability-braces-around-statements]
    if (noise_flag)
                   ^
./backends/clifford_backend.hpp:194:28: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (ideal_sim == false)
                           ^
./backends/clifford_backend.hpp:214:34: warning: variable 'gateset' defined in a header file; variable definitions in header files can lead to ODR violations [misc-definitions-in-headers]
const gateset_t CliffordBackend::gateset({// Core gates
                                 ^
./backends/clifford_backend.hpp:247:23: warning: function 'qc_measure' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_measure(const uint_t qubit, const uint_t cbit) {
                      ^
inline 
./backends/clifford_backend.hpp:262:23: warning: implicit cast bool -> 'const uint_t' [readability-implicit-bool-cast]
  const uint_t meas = qreg.MeasZ(qubit, n); // Actual measurement outcome
                      ^
                      static_cast<const uint_t>( )
./backends/clifford_backend.hpp:273:23: warning: function 'qc_reset' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_reset(const uint_t qubit, const uint_t state) {
                      ^
inline 
./backends/clifford_backend.hpp:286:14: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (r == 1)
             ^
./backends/clifford_backend.hpp:290:56: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (noise_flag && gate_error("reset").ideal == false)
                                                       ^
./backends/clifford_backend.hpp:298:23: warning: function 'qc_gate_h' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_gate_h(uint_t qubit) {
                      ^
inline 
./backends/clifford_backend.hpp:307:43: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (gate_error("gate").ideal == false)
                                          ^
./backends/clifford_backend.hpp:310:47: warning: statement should be inside braces [readability-braces-around-statements]
    else if (gate_error("X90").ideal == false)
                                              ^
./backends/clifford_backend.hpp:316:23: warning: function 'qc_gate_s' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_gate_s(uint_t qubit) {
                      ^
inline 
./backends/clifford_backend.hpp:324:55: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (noise_flag && gate_error("gate").ideal == false)
                                                      ^
./backends/clifford_backend.hpp:329:23: warning: function 'qc_gate_sdg' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_gate_sdg(uint_t qubit) {
                      ^
inline 
./backends/clifford_backend.hpp:338:55: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (noise_flag && gate_error("gate").ideal == false)
                                                      ^
./backends/clifford_backend.hpp:343:23: warning: function 'qc_gate_x' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_gate_x(uint_t qubit) {
                      ^
inline 
./backends/clifford_backend.hpp:362:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  } else
        ^
./backends/clifford_backend.hpp:367:23: warning: function 'qc_gate_y' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_gate_y(uint_t qubit) {
                      ^
inline 
./backends/clifford_backend.hpp:389:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  } else
        ^
./backends/clifford_backend.hpp:394:23: warning: function 'qc_gate_z' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_gate_z(uint_t qubit) {
                      ^
inline 
./backends/clifford_backend.hpp:402:55: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (noise_flag && gate_error("gate").ideal == false)
                                                      ^
./backends/clifford_backend.hpp:407:23: warning: function 'qc_idle' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_idle(uint_t qubit) {
                      ^
inline 
./backends/clifford_backend.hpp:423:23: warning: function 'qc_cnot' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_cnot(uint_t qubit_c, uint_t qubit_t) {
                      ^
inline 
./backends/clifford_backend.hpp:445:23: warning: function 'qc_cz' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_cz(uint_t qubit_c, uint_t qubit_t) {
                      ^
inline 
./backends/clifford_backend.hpp:471:23: warning: function 'qc_pauli' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_pauli(const uint_t qubit, const uint_t p) {
                      ^
inline 
./backends/clifford_backend.hpp:503:23: warning: function 'qc_noise' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_noise(uint_t qubit, const GateError &gate, bool X90) {
                      ^
inline 
./backends/clifford_backend.hpp:513:23: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (X90 && err == 1)
                      ^
./backends/clifford_backend.hpp:515:28: warning: statement should be inside braces [google-readability-braces-around-statements]
  else if (X90 && err == 2)
                           ^
./backends/clifford_backend.hpp:527:23: warning: function 'qc_noise' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_noise(const uint_t qubit_c, const uint_t qubit_t,
                      ^
inline 
./backends/clifford_backend.hpp:544:23: warning: function 'qc_relax' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_relax(const uint_t qubit, const double time) {
                      ^
inline 
./backends/clifford_backend.hpp:554:52: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (p_relax > 0. && rng.rand(0., 1.) < p_relax)
                                                   ^
./backends/clifford_backend.hpp:559:23: warning: function 'qc_u0' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void CliffordBackend::qc_u0(const uint_t qubit, const double n) {
                      ^
inline 
./backends/clifford_backend.hpp:577:2: warning: namespace 'QISKIT' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace QISKIT
./backends/clifford_backend.hpp:28:11: note: namespace 'QISKIT' starts here
namespace QISKIT {
          ^
./backends/ideal_backend.hpp:55:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override]
  void set_config(json_t &config);
       ^
                                  override
./backends/ideal_backend.hpp:56:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
  virtual void initialize(const Circuit &prog);
               ^
                                               override
./backends/ideal_backend.hpp:57:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
  virtual void qc_operation(const operation &op);
               ^
                                                 override
./backends/ideal_backend.hpp:92:16: warning: function 'QISKIT::IdealBackend::qc_measure' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  virtual void qc_measure(const uint_t qubit, const uint_t bit);
               ^
                                                           cbit
./backends/ideal_backend.hpp:443:20: note: the definition seen here
void IdealBackend::qc_measure(const uint_t qubit, const uint_t cbit) {
                   ^
./backends/ideal_backend.hpp:92:16: note: differing parameters are named here: ('bit'), in definition: ('cbit')
  virtual void qc_measure(const uint_t qubit, const uint_t bit);
               ^
./backends/ideal_backend.hpp:112:16: warning: function 'QISKIT::IdealBackend::qc_cnot' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  virtual void qc_cnot(const uint_t qctrl, const uint_t qtrgt);
               ^
                                    q_ctrl              q_trgt
./backends/ideal_backend.hpp:379:20: note: the definition seen here
void IdealBackend::qc_cnot(const uint_t q_ctrl, const uint_t q_trgt) {
                   ^
./backends/ideal_backend.hpp:112:16: note: differing parameters are named here: ('qctrl', 'qtrgt'), in definition: ('q_ctrl', 'q_trgt')
  virtual void qc_cnot(const uint_t qctrl, const uint_t qtrgt);
               ^
./backends/ideal_backend.hpp:113:16: warning: function 'QISKIT::IdealBackend::qc_cz' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  virtual void qc_cz(const uint_t q0, const uint_t q1);
               ^
                                  q_ctrl           q_trgt
./backends/ideal_backend.hpp:389:20: note: the definition seen here
void IdealBackend::qc_cz(const uint_t q_ctrl, const uint_t q_trgt) {
                   ^
./backends/ideal_backend.hpp:113:16: note: differing parameters are named here: ('q0', 'q1'), in definition: ('q_ctrl', 'q_trgt')
  virtual void qc_cz(const uint_t q0, const uint_t q1);
               ^
./backends/ideal_backend.hpp:123:20: warning: function 'set_config' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::set_config(json_t &config) {
                   ^
inline 
./backends/ideal_backend.hpp:135:30: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (renorm_initial_state)
                             ^
./backends/ideal_backend.hpp:138:36: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (initial_state.qubits() > 0)
                                   ^
./backends/ideal_backend.hpp:143:20: warning: function 'initialize' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::initialize(const Circuit &prog) {
                   ^
inline 
./backends/ideal_backend.hpp:146:52: warning: statement should be inside braces [readability-braces-around-statements]
    if (qreg_init.size() == (1ULL << prog.nqubits))
                                                   ^
./backends/ideal_backend.hpp:163:3: warning: missing username/bug in TODO [google-readability-todo]
  // TODO: make a ClassicalRegister class using BinaryVector
  ^
  // TODO(jgomez): make a ClassicalRegister class using BinaryVector
./backends/ideal_backend.hpp:169:20: warning: function 'qc_operation' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_operation(const operation &op) {
                   ^
inline 
./backends/ideal_backend.hpp:271:31: warning: variable 'gateset' defined in a header file; variable definitions in header files can lead to ODR violations [misc-definitions-in-headers]
const gateset_t IdealBackend::gateset({// Core gates
                              ^
./backends/ideal_backend.hpp:312:25: warning: function 'vectorize_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t IdealBackend::vectorize_matrix(const cmatrix_t &mat) const {
                        ^
inline 
./backends/ideal_backend.hpp:316:40: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (size_t j=0; j < mat.size(); j++)
                                       ^
./backends/ideal_backend.hpp:325:20: warning: function 'qc_gate' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_gate(const uint_t qubit, const double theta,
                   ^
inline 
./backends/ideal_backend.hpp:336:20: warning: function 'qc_gate_x' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_gate_x(const uint_t qubit) {
                   ^
inline 
./backends/ideal_backend.hpp:345:20: warning: function 'qc_gate_y' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_gate_y(const uint_t qubit) {
                   ^
inline 
./backends/ideal_backend.hpp:355:20: warning: function 'qc_phase' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_phase(const uint_t qubit, const complex_t phase) {
                   ^
inline 
./backends/ideal_backend.hpp:365:20: warning: function 'qc_zrot' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_zrot(const uint_t qubit, const double lambda) {
                   ^
inline 
./backends/ideal_backend.hpp:379:20: warning: function 'qc_cnot' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_cnot(const uint_t q_ctrl, const uint_t q_trgt) {
                   ^
inline 
./backends/ideal_backend.hpp:389:20: warning: function 'qc_cz' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_cz(const uint_t q_ctrl, const uint_t q_trgt) {
                   ^
inline 
./backends/ideal_backend.hpp:399:20: warning: function 'qc_zzrot' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_zzrot(const uint_t q0, const uint_t q1,
                   ^
inline 
./backends/ideal_backend.hpp:419:25: warning: function 'waltz_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cmatrix_t IdealBackend::waltz_matrix(double theta, double phi, double lambda) {
                        ^
inline 
./backends/ideal_backend.hpp:429:25: warning: function 'waltz_vectorized_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t IdealBackend::waltz_vectorized_matrix(double theta, double phi, double lambda) {
                        ^
inline 
./backends/ideal_backend.hpp:443:20: warning: function 'qc_measure' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_measure(const uint_t qubit, const uint_t cbit) {
                   ^
inline 
./backends/ideal_backend.hpp:460:41: warning: function 'qc_measure_outcome' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::pair<uint_t, double> IdealBackend::qc_measure_outcome(const uint_t qubit) {
                                        ^
inline 
./backends/ideal_backend.hpp:474:20: warning: function 'qc_reset' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void IdealBackend::qc_reset(const uint_t qubit, const uint_t state) {
                   ^
inline 
./backends/ideal_backend.hpp:487:27: warning: statement should be inside braces [readability-braces-around-statements]
  if (state != meas.first)
                          ^
./backends/noise_models.hpp:119:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  ResetError(const std::discrete_distribution<> &probs);
  ^
  explicit 
./backends/noise_models.hpp:127:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  ResetError(const rvector_t &probs);
  ^
  explicit 
./backends/noise_models.hpp:169:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  ReadoutError(const std::vector<std::discrete_distribution<>> &probs);
  ^
  explicit 
./backends/noise_models.hpp:177:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  ReadoutError(double p1);
  ^
  explicit 
./backends/noise_models.hpp:186:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  ReadoutError(const std::vector<rvector_t> &probs);
  ^
  explicit 
./backends/noise_models.hpp:213:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  PauliChannel(uint_t nq) : n(nq){};
  ^
  explicit 
./backends/noise_models.hpp:303:20: warning: function 'p' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double Relaxation::p(double t) const {
                   ^
inline 
./backends/noise_models.hpp:307:13: warning: function 'Relaxation' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
Relaxation::Relaxation(double rate1, const std::discrete_distribution<> &pops)
            ^
inline 
./backends/noise_models.hpp:307:38: warning: pass by value and use std::move [modernize-pass-by-value]
Relaxation::Relaxation(double rate1, const std::discrete_distribution<> &pops)
                                     ^
./backends/noise_models.hpp:317:13: warning: function 'Relaxation' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
Relaxation::Relaxation(double rate1, const rvector_t &pops)
            ^
inline 
./backends/noise_models.hpp:321:18: warning: function 'verify' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool Relaxation::verify(uint_t dim) const {
                 ^
inline 
./backends/noise_models.hpp:326:5: warning: don't use else after return [readability-else-after-return]
  } else if (rate < 0) {
    ^
./backends/noise_models.hpp:329:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  } else
        ^
./backends/noise_models.hpp:346:28: warning: statement should be inside braces [readability-braces-around-statements]
      if (node.is_number())
                           ^
./backends/noise_models.hpp:348:11: warning: statement should be inside braces [readability-braces-around-statements]
      else
          ^
./backends/noise_models.hpp:352:9: warning: statement should be inside braces [readability-braces-around-statements]
  } else
        ^
./backends/noise_models.hpp:362:13: warning: function 'ResetError' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
ResetError::ResetError(const std::discrete_distribution<> &probs) : p(probs) {
            ^
inline 
./backends/noise_models.hpp:362:24: warning: pass by value and use std::move [modernize-pass-by-value]
ResetError::ResetError(const std::discrete_distribution<> &probs) : p(probs) {
                       ^
./backends/noise_models.hpp:370:13: warning: function 'ResetError' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
ResetError::ResetError(const rvector_t &probs)
            ^
inline 
./backends/noise_models.hpp:373:18: warning: function 'verify' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool ResetError::verify(uint_t dim) const {
                 ^
inline 
./backends/noise_models.hpp:377:5: warning: don't use else after return [readability-else-after-return]
  } else
    ^
./backends/noise_models.hpp:377:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  } else
        ^
./backends/noise_models.hpp:401:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  } else
        ^
./backends/noise_models.hpp:411:15: warning: function 'ReadoutError' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
ReadoutError::ReadoutError(
              ^
inline 
./backends/noise_models.hpp:412:5: warning: pass by value and use std::move [modernize-pass-by-value]
    const std::vector<std::discrete_distribution<>> &probs)
    ^
./backends/noise_models.hpp:421:15: warning: function 'ReadoutError' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
ReadoutError::ReadoutError(double p1) {
              ^
inline 
./backends/noise_models.hpp:434:15: warning: function 'ReadoutError' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
ReadoutError::ReadoutError(const std::vector<rvector_t> &probs) {
              ^
inline 
./backends/noise_models.hpp:436:30: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (auto const &v : probs)
                             ^
./backends/noise_models.hpp:446:20: warning: function 'verify' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool ReadoutError::verify(uint_t dim) const {
                   ^
inline 
./backends/noise_models.hpp:450:5: warning: don't use else after return [readability-else-after-return]
  } else {
    ^
./backends/noise_models.hpp:465:37: warning: statement should be inside braces [readability-braces-around-statements]
    for (auto const &dist : error.p)
                                    ^
./backends/noise_models.hpp:498:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  } else
        ^
./backends/noise_models.hpp:508:15: warning: function 'PauliChannel' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
PauliChannel::PauliChannel(uint_t nq, rvector_t p_pauli) : n(nq) {
              ^
inline 
./backends/noise_models.hpp:512:20: warning: function 'set_p' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void PauliChannel::set_p(rvector_t p_pauli) {
                   ^
inline 
./backends/noise_models.hpp:516:27: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (auto &pj : p_pauli)
                          ^
./backends/noise_models.hpp:520:50: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (p_pauli.size() > N || tot > 1. || tot < 0.)
                                                 ^
./backends/noise_models.hpp:528:25: warning: function 'p_errors' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t PauliChannel::p_errors() const {
                        ^
inline 
./backends/noise_models.hpp:542:17: warning: function 'verify' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool GateError::verify(uint_t dim) const {
                ^
inline 
./backends/noise_models.hpp:546:5: warning: don't use else after return [readability-else-after-return]
  } else if (gate_time < 0.) {
    ^
./backends/noise_models.hpp:549:9: warning: statement should be inside braces [readability-braces-around-statements]
  } else
        ^
./backends/noise_models.hpp:556:30: warning: statement should be inside braces [readability-braces-around-statements]
    if (error.gate_time > 0.)
                             ^
./backends/noise_models.hpp:558:36: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (error.pauli.ideal == false)
                                   ^
./backends/noise_models.hpp:560:55: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (error.coherent_error && error.Uerr.size() > 0)
                                                      ^
./backends/noise_models.hpp:571:32: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (JSON::check_key(key, js))
                               ^
./backends/noise_models.hpp:573:7: warning: statement should be inside braces [readability-braces-around-statements]
  else
      ^
./backends/noise_models.hpp:578:28: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (error.gate_time > 0.)
                           ^
./backends/noise_models.hpp:595:28: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (auto &p : p_pauli)
                           ^
./backends/noise_models.hpp:599:18: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
  error.ideal &= error.pauli.ideal;
                 ^
                 static_cast<int>()
./backends/noise_models.hpp:609:18: warning: function 'verify' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool QubitNoise::verify(uint_t dim) {
                 ^
inline 
./backends/noise_models.hpp:620:17: warning: variable 'gate_names' defined in a header file; variable definitions in header files can lead to ODR violations [misc-definitions-in-headers]
    QubitNoise::gate_names({"X90", "CX", "CZ", "id", "U", "measure", "reset"});
                ^
./backends/noise_models.hpp:639:20: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    noise.ideal &= noise.reset.ideal;
                   ^
                   static_cast<int>()
./backends/noise_models.hpp:641:20: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    noise.ideal &= noise.readout.ideal;
                   ^
                   static_cast<int>(  )
./backends/noise_models.hpp:643:20: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    noise.ideal &= !(noise.relax.rate > 0.);
                   ^
                   static_cast<int>(       )
./backends/noise_models.hpp:647:36: warning: statement should be inside braces [google-readability-braces-around-statements]
        if (n == "CX" || n == "CZ")
                                   ^
./backends/noise_models.hpp:649:13: warning: statement should be inside braces [readability-braces-around-statements]
        else
            ^
./backends/noise_models.hpp:657:53: warning: statement should be inside braces [readability-braces-around-statements]
          for (size_t i=0; i < check.GetRows(); i++)
                                                    ^
./backends/noise_models.hpp:669:24: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
        noise.ideal &= g.ideal;
                       ^
                       static_cast<int>( )
./backends/qubit_backend.hpp:41:7: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
class QubitBackend : public IdealBackend {
      ^
./backends/qubit_backend.hpp:53:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override]
  void initialize(const Circuit &prog);
       ^
                                       override
./backends/qubit_backend.hpp:54:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override]
  void qc_operation(const operation &op);
       ^
                                         override
./backends/qubit_backend.hpp:61:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
  virtual void qc_reset(const uint_t qubit, const uint_t state = 0);
               ^
                                                                    override
./backends/qubit_backend.hpp:62:16: warning: function 'QISKIT::QubitBackend::qc_measure' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  virtual void qc_measure(const uint_t qubit, const uint_t bit);
               ^
                                                           cbit
./backends/qubit_backend.hpp:273:20: note: the definition seen here
void QubitBackend::qc_measure(const uint_t qubit, const uint_t cbit) {
                   ^
./backends/qubit_backend.hpp:62:16: note: differing parameters are named here: ('bit'), in definition: ('cbit')
  virtual void qc_measure(const uint_t qubit, const uint_t bit);
               ^
./backends/qubit_backend.hpp:62:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
  virtual void qc_measure(const uint_t qubit, const uint_t bit);
               ^
                                                                override
./backends/qubit_backend.hpp:69:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
  virtual void qc_gate(const uint_t qubit, const double theta, const double phi,
               ^
./backends/qubit_backend.hpp:72:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
  virtual void qc_gate_x(const uint_t qubit);
               ^
                                             override
./backends/qubit_backend.hpp:73:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
  virtual void qc_gate_y(const uint_t qubit);
               ^
                                             override
./backends/qubit_backend.hpp:82:16: warning: function 'QISKIT::QubitBackend::qc_cnot' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  virtual void qc_cnot(const uint_t qctrl, const uint_t qtrgt);
               ^
                                    qubit_ctrl          qubit_targ
./backends/qubit_backend.hpp:487:20: note: the definition seen here
void QubitBackend::qc_cnot(const uint_t qubit_ctrl, const uint_t qubit_targ) {
                   ^
./backends/qubit_backend.hpp:82:16: note: differing parameters are named here: ('qctrl', 'qtrgt'), in definition: ('qubit_ctrl', 'qubit_targ')
  virtual void qc_cnot(const uint_t qctrl, const uint_t qtrgt);
               ^
./backends/qubit_backend.hpp:82:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
  virtual void qc_cnot(const uint_t qctrl, const uint_t qtrgt);
               ^
                                                               override
./backends/qubit_backend.hpp:83:16: warning: function 'QISKIT::QubitBackend::qc_cz' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  virtual void qc_cz(const uint_t q0, const uint_t q1);
               ^
                                  qubit_ctrl       qubit_targ
./backends/qubit_backend.hpp:511:20: note: the definition seen here
void QubitBackend::qc_cz(const uint_t qubit_ctrl, const uint_t qubit_targ) {
                   ^
./backends/qubit_backend.hpp:83:16: note: differing parameters are named here: ('q0', 'q1'), in definition: ('qubit_ctrl', 'qubit_targ')
  virtual void qc_cz(const uint_t q0, const uint_t q1);
               ^
./backends/qubit_backend.hpp:83:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override]
  virtual void qc_cz(const uint_t q0, const uint_t q1);
               ^
                                                       override
./backends/qubit_backend.hpp:95:8: warning: function 'QISKIT::QubitBackend::add_pauli' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void add_pauli(const uint_t p, cmatrix_t &U);
       ^
                              j
./backends/qubit_backend.hpp:551:20: note: the definition seen here
void QubitBackend::add_pauli(const uint_t j, cmatrix_t &U) {
                   ^
./backends/qubit_backend.hpp:95:8: note: differing parameters are named here: ('p'), in definition: ('j')
  void add_pauli(const uint_t p, cmatrix_t &U);
       ^
./backends/qubit_backend.hpp:96:8: warning: function 'QISKIT::QubitBackend::add_pauli2' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void add_pauli2(const uint_t p, cmatrix_t &U);
       ^
                               j
./backends/qubit_backend.hpp:556:20: note: the definition seen here
void QubitBackend::add_pauli2(const uint_t j, cmatrix_t &U) {
                   ^
./backends/qubit_backend.hpp:96:8: note: differing parameters are named here: ('p'), in definition: ('j')
  void add_pauli2(const uint_t p, cmatrix_t &U);
       ^
./backends/qubit_backend.hpp:114:20: warning: function 'initialize' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::initialize(const Circuit &prog) {
                   ^
inline 
./backends/qubit_backend.hpp:121:20: warning: function 'qc_operation' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_operation(const operation &op) {
                   ^
inline 
./backends/qubit_backend.hpp:193:20: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (noise_flag)
                   ^
./backends/qubit_backend.hpp:207:28: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (ideal_sim == false)
                           ^
./backends/qubit_backend.hpp:227:15: warning: function 'QubitBackend' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitBackend::QubitBackend() : IdealBackend() {
              ^
inline 
./backends/qubit_backend.hpp:244:33: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint_t i = 0; i < 4; i++)
                                ^
./backends/qubit_backend.hpp:245:35: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (uint_t j = 0; j < 4; j++)
                                  ^
./backends/qubit_backend.hpp:246:7: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
      pauli2[i * 4 + j] = MOs::TensorProduct(pauli[i], pauli[j]);
      ^
./backends/qubit_backend.hpp:246:46: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
      pauli2[i * 4 + j] = MOs::TensorProduct(pauli[i], pauli[j]);
                                             ^
./backends/qubit_backend.hpp:246:56: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
      pauli2[i * 4 + j] = MOs::TensorProduct(pauli[i], pauli[j]);
                                                       ^
./backends/qubit_backend.hpp:273:20: warning: function 'qc_measure' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_measure(const uint_t qubit, const uint_t cbit) {
                   ^
inline 
./backends/qubit_backend.hpp:304:20: warning: function 'qc_reset' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_reset(const uint_t qubit, const uint_t state) {
                   ^
inline 
./backends/qubit_backend.hpp:324:20: warning: function 'qc_gate' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_gate(const uint_t qubit, const double theta,
                   ^
inline 
./backends/qubit_backend.hpp:338:59: warning: statement should be inside braces [google-readability-braces-around-statements]
  else if (noise_flag && gate_error("X90").ideal == false)
                                                          ^
./backends/qubit_backend.hpp:341:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./backends/qubit_backend.hpp:346:20: warning: function 'qc_u0' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_u0(const uint_t qubit, const double n) {
                   ^
inline 
./backends/qubit_backend.hpp:362:20: warning: function 'qc_u1' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_u1(const uint_t qubit, const double lambda) {
                   ^
inline 
./backends/qubit_backend.hpp:373:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./backends/qubit_backend.hpp:377:20: warning: function 'qc_u2' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_u2(const uint_t qubit, const double phi,
                   ^
inline 
./backends/qubit_backend.hpp:400:9: warning: statement should be inside braces [google-readability-braces-around-statements]
    else
        ^
./backends/qubit_backend.hpp:405:20: warning: function 'qc_u3' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_u3(const uint_t qubit, const double theta,
                   ^
inline 
./backends/qubit_backend.hpp:425:11: warning: statement should be inside braces [google-readability-braces-around-statements]
    } else // ideal single qubit unitary
          ^
./backends/qubit_backend.hpp:430:20: warning: function 'qc_gate_x' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_gate_x(const uint_t qubit) {
                   ^
inline 
./backends/qubit_backend.hpp:438:35: warning: missing username/bug in TODO [google-readability-todo]
    qc_u3(qubit, M_PI, 0., M_PI); // TODO update
                                  ^
                                  // TODO(jgomez): update
./backends/qubit_backend.hpp:450:20: warning: function 'qc_gate_y' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_gate_y(const uint_t qubit) {
                   ^
inline 
./backends/qubit_backend.hpp:459:47: warning: missing username/bug in TODO [google-readability-todo]
    qc_u3(qubit, M_PI, M_PI / 2., M_PI / 2.); // TODO update
                                              ^
                                              // TODO(jgomez): update
./backends/qubit_backend.hpp:471:20: warning: function 'qc_idle' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_idle(const uint_t qubit) {
                   ^
inline 
./backends/qubit_backend.hpp:487:20: warning: function 'qc_cnot' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_cnot(const uint_t qubit_ctrl, const uint_t qubit_targ) {
                   ^
inline 
./backends/qubit_backend.hpp:507:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  } else
        ^
./backends/qubit_backend.hpp:511:20: warning: function 'qc_cz' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_cz(const uint_t qubit_ctrl, const uint_t qubit_targ) {
                   ^
inline 
./backends/qubit_backend.hpp:531:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  } else
        ^
./backends/qubit_backend.hpp:538:25: warning: function 'rz_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cmatrix_t QubitBackend::rz_matrix(const double lambda) {
                        ^
inline 
./backends/qubit_backend.hpp:551:20: warning: function 'add_pauli' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::add_pauli(const uint_t j, cmatrix_t &U) {
                   ^
inline 
./backends/qubit_backend.hpp:552:23: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (j != 0 && j < 4)
                      ^
./backends/qubit_backend.hpp:553:9: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    U = pauli[j] * U;
        ^
./backends/qubit_backend.hpp:556:20: warning: function 'add_pauli2' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::add_pauli2(const uint_t j, cmatrix_t &U) {
                   ^
inline 
./backends/qubit_backend.hpp:557:24: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (j != 0 && j < 16)
                       ^
./backends/qubit_backend.hpp:558:9: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    U = pauli2[j] * U;
        ^
./backends/qubit_backend.hpp:561:25: warning: function 'noise_matrix1' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cmatrix_t QubitBackend::noise_matrix1(const cmatrix_t &U,
                        ^
inline 
./backends/qubit_backend.hpp:563:17: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (err.ideal) // If ideal return original matrix
                ^
./backends/qubit_backend.hpp:572:25: warning: function 'noise_matrix2' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cmatrix_t QubitBackend::noise_matrix2(const cmatrix_t &U,
                        ^
inline 
./backends/qubit_backend.hpp:574:17: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (err.ideal) // If ideal return original matrix
                ^
./backends/qubit_backend.hpp:587:20: warning: function 'qc_relax' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_relax(const uint_t qubit, const double time) {
                   ^
inline 
./backends/qubit_backend.hpp:596:52: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (p_relax > 0. && rng.rand(0., 1.) < p_relax)
                                                   ^
./backends/qubit_backend.hpp:601:20: warning: function 'qc_matrix1_noise' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitBackend::qc_matrix1_noise(const uint_t qubit, const cmatrix_t &U,
                   ^
inline 
./backends/rng_engine.hpp:105:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  RngEngine(uint_t seed) { rng.seed(seed); };
  ^
  explicit 
./backends/rng_engine.hpp:117:19: warning: function 'rand' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double RngEngine::rand(double a, double b) {
                  ^
inline 
./backends/rng_engine.hpp:128:18: warning: function 'rand_int' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
int_t RngEngine::rand_int(int_t a, int_t b) {
                 ^
inline 
./backends/rng_engine.hpp:139:18: warning: function 'rand_int' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
int_t RngEngine::rand_int(std::discrete_distribution<> probs) {
                 ^
inline 
./backends/rng_engine.hpp:150:18: warning: function 'rand_int' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
int_t RngEngine::rand_int(std::vector<double> probs) {
                 ^
inline 
./engines/base_engine.hpp:101:3: warning: use '= default' to define a trivial default constructor [modernize-use-default]
  BaseEngine(){};
  ^
              = default;
./engines/base_engine.hpp:102:3: warning: use '= default' to define a trivial destructor [modernize-use-default]
  virtual ~BaseEngine(){};
  ^
                       = default;
./engines/base_engine.hpp:117:16: warning: function 'QISKIT::BaseEngine::run_program' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  virtual void run_program(Circuit &circ, BaseBackend<StateType> *be,
               ^
                                    prog
./engines/base_engine.hpp:156:29: note: the definition seen here
void BaseEngine<StateType>::run_program(Circuit &prog,
                            ^
./engines/base_engine.hpp:117:16: note: differing parameters are named here: ('circ'), in definition: ('prog')
  virtual void run_program(Circuit &circ, BaseBackend<StateType> *be,
               ^
./engines/base_engine.hpp:120:16: warning: function 'QISKIT::BaseEngine::execute' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  virtual void execute(Circuit &circ, BaseBackend<StateType> *be,
               ^
                                prog
./engines/base_engine.hpp:176:29: note: the definition seen here
void BaseEngine<StateType>::execute(Circuit &prog, BaseBackend<StateType> *be,
                            ^
./engines/base_engine.hpp:120:16: note: differing parameters are named here: ('circ'), in definition: ('prog')
  virtual void execute(Circuit &circ, BaseBackend<StateType> *be,
               ^
./engines/base_engine.hpp:144:16: warning: function 'QISKIT::BaseEngine::compute_results' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  virtual void compute_results(Circuit &circ, BaseBackend<StateType> *be);
               ^
                                        qasm
./engines/base_engine.hpp:186:29: note: the definition seen here
void BaseEngine<StateType>::compute_results(Circuit &qasm,
                            ^
./engines/base_engine.hpp:144:16: note: differing parameters are named here: ('circ'), in definition: ('qasm')
  virtual void compute_results(Circuit &circ, BaseBackend<StateType> *be);
               ^
./engines/base_engine.hpp:171:26: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (initial_state_flag)
                         ^
./engines/base_engine.hpp:192:65: warning: statement should be inside braces [readability-braces-around-statements]
  if (show_snapshots && be->access_snapshots().empty() == false)
                                                                ^
./engines/base_engine.hpp:211:24: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (counts_space)
                       ^
./engines/base_engine.hpp:214:50: warning: statement should be inside braces [readability-braces-around-statements]
    if (shotstr.empty() == false && counts_space)
                                                 ^
./engines/base_engine.hpp:218:33: warning: statement should be inside braces [readability-braces-around-statements]
    if (counts_bits_h2l == true)
                                ^
./engines/base_engine.hpp:222:49: warning: statement should be inside braces [readability-braces-around-statements]
    if (counts_show && shotstr.empty() == false)
                                                ^
./engines/base_engine.hpp:226:53: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (show_final_creg && shotstr.empty() == false)
                                                    ^
./engines/base_engine.hpp:240:31: warning: statement should be inside braces [readability-braces-around-statements]
  for (auto pair : eng.counts)
                              ^
./engines/base_engine.hpp:244:37: warning: statement should be inside braces [readability-braces-around-statements]
  for (const auto &s: eng.snapshots)
                                    ^
./engines/base_engine.hpp:262:60: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (engine.counts_show && engine.counts.empty() == false)
                                                           ^
./engines/base_engine.hpp:265:69: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (engine.show_final_creg && engine.output_creg.empty() == false)
                                                                    ^
./engines/base_engine.hpp:272:47: warning: statement should be inside braces [readability-braces-around-statements]
      for (const auto& pair: engine.snapshots)
                                              ^
./engines/base_engine.hpp:273:53: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        js["snapshots"][std::to_string(pair.first)]["quantum_state"] = pair.second;
                                                    ^
./engines/base_engine.hpp:291:29: warning: statement should be inside braces [readability-braces-around-statements]
      if (o == "hidecounts")
                            ^
./engines/base_engine.hpp:293:31: warning: statement should be inside braces [readability-braces-around-statements]
      else if (o == "nospace")
                              ^
./engines/base_engine.hpp:295:30: warning: statement should be inside braces [google-readability-braces-around-statements]
      else if (o == "nosort")
                             ^
./engines/base_engine.hpp:297:31: warning: statement should be inside braces [google-readability-braces-around-statements]
      else if (o == "reverse")
                              ^
./engines/base_engine.hpp:299:64: warning: statement should be inside braces [google-readability-braces-around-statements]
      else if (o == "classicalstate" || o == "classicalstates")
                                                               ^
./engines/base_engine.hpp:301:61: warning: statement should be inside braces [google-readability-braces-around-statements]
      else if (o == "hidesnapshots" || o == "hidesnapshots")
                                                            ^
./engines/vector_engine.hpp:29:1: warning: #includes are not sorted properly [llvm-include-order]
#include "qubit_vector.hpp"
^
./engines/vector_engine.hpp:60:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  VectorEngine(uint_t dim = 2) : BaseEngine<QubitVector>(), qudit_dim(dim){};
  ^
  explicit 
./engines/vector_engine.hpp:92:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override]
  void execute(Circuit &circ, BaseBackend<QubitVector> *be, uint_t nshots);
       ^
                                                                           override
./engines/vector_engine.hpp:92:8: warning: function 'QISKIT::VectorEngine::execute' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void execute(Circuit &circ, BaseBackend<QubitVector> *be, uint_t nshots);
       ^
                        prog
./engines/vector_engine.hpp:168:20: note: the definition seen here
void VectorEngine::execute(Circuit &prog, BaseBackend<QubitVector> *be,
                   ^
./engines/vector_engine.hpp:92:8: note: differing parameters are named here: ('circ'), in definition: ('prog')
  void execute(Circuit &circ, BaseBackend<QubitVector> *be, uint_t nshots);
       ^
./engines/vector_engine.hpp:104:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override]
  void compute_results(Circuit &circ, BaseBackend<QubitVector> *be);
       ^
                                                                    override
./engines/vector_engine.hpp:104:8: warning: function 'QISKIT::VectorEngine::compute_results' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void compute_results(Circuit &circ, BaseBackend<QubitVector> *be);
       ^
                                qasm
./engines/vector_engine.hpp:331:20: note: the definition seen here
void VectorEngine::compute_results(Circuit &qasm, BaseBackend<QubitVector> *be) {
                   ^
./engines/vector_engine.hpp:104:8: note: differing parameters are named here: ('circ'), in definition: ('qasm')
  void compute_results(Circuit &circ, BaseBackend<QubitVector> *be);
       ^
./engines/vector_engine.hpp:128:20: warning: function 'add' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void VectorEngine::add(const VectorEngine &eng) {
                   ^
inline 
./engines/vector_engine.hpp:135:41: warning: statement should be inside braces [readability-braces-around-statements]
  for (const auto &s: eng.snapshots_ket)
                                        ^
./engines/vector_engine.hpp:142:25: warning: statement should be inside braces [readability-braces-around-statements]
    if (rho.size() == 0)
                        ^
./engines/vector_engine.hpp:144:9: warning: statement should be inside braces [readability-braces-around-statements]
    else
        ^
./engines/vector_engine.hpp:154:48: warning: statement should be inside braces [readability-braces-around-statements]
  for (const auto &s : eng.snapshots_probs_ket)
                                               ^
./engines/vector_engine.hpp:158:47: warning: statement should be inside braces [readability-braces-around-statements]
  for (const auto &s : eng.snapshots_overlaps)
                                              ^
./engines/vector_engine.hpp:162:46: warning: statement should be inside braces [readability-braces-around-statements]
  for (const auto &s : eng.snapshots_inprods)
                                             ^
./engines/vector_engine.hpp:168:20: warning: function 'execute' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void VectorEngine::execute(Circuit &prog, BaseBackend<QubitVector> *be,
                   ^
inline 
./engines/vector_engine.hpp:195:32: warning: statement should be inside braces [readability-braces-around-statements]
    for (const auto &op : meas)
                               ^
./engines/vector_engine.hpp:206:7: warning: use range-based for loop instead [modernize-loop-convert]
      for (uint_t j=0; j < cprobs.size(); j++) {
      ^
./engines/vector_engine.hpp:229:34: warning: statement should be inside braces [readability-braces-around-statements]
  for (auto &qubit : meas_qubits)
                                 ^
./engines/vector_engine.hpp:240:47: warning: statement should be inside braces [readability-braces-around-statements]
      if (r < (p += std::real(probs[result])))
                                              ^
./engines/vector_engine.hpp:245:67: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (auto it = outcomes.cbegin(); it != outcomes.cend(); it++)
                                                                  ^
./engines/vector_engine.hpp:249:32: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (const auto &op : meas)
                               ^
./engines/vector_engine.hpp:258:20: warning: function 'snapshot_ketform' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void VectorEngine::snapshot_ketform(const std::map<int, QubitVector>& qreg_snapshots,
                   ^
inline 
./engines/vector_engine.hpp:264:30: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (show_snapshots_ket)
                             ^
./engines/vector_engine.hpp:278:20: warning: function 'snapshot_density_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void VectorEngine::snapshot_density_matrix(const std::map<int, QubitVector>& qreg_snapshots) {
                   ^
inline 
./engines/vector_engine.hpp:282:27: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (rho.size() == 0)
                          ^
./engines/vector_engine.hpp:284:11: warning: statement should be inside braces [google-readability-braces-around-statements]
      else
          ^
./engines/vector_engine.hpp:290:20: warning: function 'snapshot_probabilities' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void VectorEngine::snapshot_probabilities(const std::map<int, QubitVector>& qreg_snapshots) {
                   ^
inline 
./engines/vector_engine.hpp:294:24: warning: statement should be inside braces [google-readability-braces-around-statements]
        if (pr.empty())
                       ^
./engines/vector_engine.hpp:296:13: warning: statement should be inside braces [google-readability-braces-around-statements]
        else
            ^
./engines/vector_engine.hpp:302:20: warning: function 'snapshot_inner_products' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void VectorEngine::snapshot_inner_products(const std::map<int, QubitVector>& qreg_snapshots) {
                   ^
inline 
./engines/vector_engine.hpp:322:42: warning: statement should be inside braces [google-readability-braces-around-statements]
        if (show_snapshots_inner_product)
                                         ^
./engines/vector_engine.hpp:325:37: warning: statement should be inside braces [google-readability-braces-around-statements]
        if (show_snapshots_overlaps)
                                    ^
./engines/vector_engine.hpp:331:20: warning: function 'compute_results' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void VectorEngine::compute_results(Circuit &qasm, BaseBackend<QubitVector> *be) {
                   ^
inline 
./engines/vector_engine.hpp:342:85: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (auto it = qasm.qubit_sizes.crbegin(); it != qasm.qubit_sizes.crend(); ++it)
                                                                                    ^
./engines/vector_engine.hpp:359:22: warning: function 'get_probs' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double VectorEngine::get_probs(const complex_t &val) const {
                     ^
inline 
./engines/vector_engine.hpp:363:25: warning: function 'get_probs' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t VectorEngine::get_probs(const QubitVector &vec) const {
                        ^
inline 
./engines/vector_engine.hpp:365:39: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (const auto &elt : vec.vector())
                                      ^
./engines/vector_engine.hpp:370:45: warning: function 'get_probs' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::map<std::string, double> VectorEngine::get_probs(const cket_t &ket) const {
                                            ^
inline 
./engines/vector_engine.hpp:372:30: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (const auto &elt : ket)
                             ^
./engines/vector_engine.hpp:395:43: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (const auto& s: eng.snapshots_ket)
                                          ^
./engines/vector_engine.hpp:460:61: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (o == "quantumstateket" || o == "quantumstatesket")
                                                            ^
./engines/vector_engine.hpp:462:37: warning: statement should be inside braces [google-readability-braces-around-statements]
      else if (o == "densitymatrix")
                                    ^
./engines/vector_engine.hpp:464:53: warning: statement should be inside braces [readability-braces-around-statements]
      else if (o == "probabilities" || o == "probs")
                                                    ^
./engines/vector_engine.hpp:466:59: warning: statement should be inside braces [google-readability-braces-around-statements]
      else if (o == "probabilitiesket" || o == "probsket")
                                                          ^
./engines/vector_engine.hpp:468:48: warning: statement should be inside braces [google-readability-braces-around-statements]
      else if (o == "targetstatesinnerproduct")
                                               ^
./engines/vector_engine.hpp:470:44: warning: statement should be inside braces [google-readability-braces-around-statements]
      else if (o == "targetstatesoverlaps")
                                           ^
./engines/vector_engine.hpp:479:30: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (eng.initial_state_flag)
                             ^
./engines/vector_engine.hpp:486:28: warning: statement should be inside braces [google-readability-braces-around-statements]
      renorm_target_states)
                           ^
./engines/vector_engine.hpp:487:39: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (auto &qv : eng.target_states)
                                      ^
./simulator.hpp:37:1: warning: #includes are not sorted properly [llvm-include-order]
#include <future> // C++11
^
./simulator.hpp:86:8: warning: function 'QISKIT::Simulator::load_qobj_json' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void load_qobj_json(const json_t &input);
       ^
                                    js
./simulator.hpp:275:17: note: the definition seen here
void Simulator::load_qobj_json(const json_t &js) {
                ^
./simulator.hpp:86:8: note: differing parameters are named here: ('input'), in definition: ('js')
  void load_qobj_json(const json_t &input);
       ^
./simulator.hpp:111:19: warning: function 'execute_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
json_t Simulator::execute_json(){
                  ^
inline 
./simulator.hpp:127:49: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (simulator == "clifford_simulator_cpp")
                                                ^
./simulator.hpp:129:33: warning: statement should be inside braces [readability-braces-around-statements]
      else if (circ.noise.ideal)
                                ^
./simulator.hpp:131:11: warning: statement should be inside braces [readability-braces-around-statements]
      else
          ^
./simulator.hpp:135:23: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      qobj_success &= circ_res["success"].get<bool>();
                      ^
                      static_cast<int>(              )
./simulator.hpp:191:43: warning: statement should be inside braces [readability-braces-around-statements]
    if (circ.noise.ideal && circ.opt_meas)
                                          ^
./simulator.hpp:196:32: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (max_threads_shot > 0)
                               ^
./simulator.hpp:199:55: warning: Division by zero [clang-analyzer-core.DivideZero]
    uint_t gate_threads = std::max<uint_t>(1UL, ncpus / threads);
                                                      ^
/home/jgomez/ibm/quantum/qiskit-sdk-py/src/qasm-simulator-cpp/src/main.cpp:53:7: note: Assuming 'argc' is equal to 2
  if (argc != 2) {
      ^
/home/jgomez/ibm/quantum/qiskit-sdk-py/src/qasm-simulator-cpp/src/main.cpp:53:3: note: Taking false branch
  if (argc != 2) {
  ^
/home/jgomez/ibm/quantum/qiskit-sdk-py/src/qasm-simulator-cpp/src/main.cpp:83:12: note: Calling 'Simulator::execute'
    out << sim.execute() << std::endl;
           ^
./simulator.hpp:82:12: note: Calling 'Simulator::execute_json'
    return execute_json().dump(indent);
           ^
./simulator.hpp:127:7: note: Taking false branch
      if (simulator == "clifford_simulator_cpp")
      ^
./simulator.hpp:129:12: note: Taking false branch
      else if (circ.noise.ideal)
           ^
./simulator.hpp:132:20: note: Calling 'Simulator::run_circuit'
        circ_res = run_circuit<VectorEngine, QubitBackend>(circ);
                   ^
./simulator.hpp:159:8: note: Left side of '||' is false
  if ((simulator == "qubit" || simulator == "ideal") &&
       ^
./simulator.hpp:159:54: note: Left side of '&&' is false
  if ((simulator == "qubit" || simulator == "ideal") &&
                                                     ^
./simulator.hpp:175:5: note: Calling 'BaseBackend::attach_noise'
    backend.attach_noise(circ.noise);
    ^
./backends/base_backend.hpp:372:3: note: Calling implicit copy assignment operator for 'QubitNoise'
  noise = np;
  ^
./backends/noise_models.hpp:270:7: note: Value assigned to field 'shots'
class QubitNoise {
      ^
./backends/base_backend.hpp:372:3: note: Returning from copy assignment operator for 'QubitNoise'
  noise = np;
  ^
./simulator.hpp:175:5: note: Returning from 'BaseBackend::attach_noise'
    backend.attach_noise(circ.noise);
    ^
./simulator.hpp:178:23: note: '?' condition is false
    uint_t rng_seed = (circ.rng_seed < 0) ? std::random_device()()
                      ^
./simulator.hpp:189:16: note: '?' condition is false
    int_t dq = (max_qubits > circ.nqubits) ? max_qubits - circ.nqubits : 0;
               ^
./simulator.hpp:191:26: note: Left side of '&&' is false
    if (circ.noise.ideal && circ.opt_meas)
                         ^
./simulator.hpp:195:43: note: Passing value via 2nd parameter '__b'
      threads = std::min<uint_t>(threads, circ.shots);
                                          ^
./simulator.hpp:195:17: note: Calling 'min'
      threads = std::min<uint_t>(threads, circ.shots);
                ^
/usr/lib/gcc/x86_64-linux-gnu/5.4.0/../../../../include/c++/5.4.0/bits/stl_algobase.h:200:11: note: Assuming '__b' is < '__a'
      if (__b < __a)
          ^
/usr/lib/gcc/x86_64-linux-gnu/5.4.0/../../../../include/c++/5.4.0/bits/stl_algobase.h:200:7: note: Taking true branch
      if (__b < __a)
      ^
/usr/lib/gcc/x86_64-linux-gnu/5.4.0/../../../../include/c++/5.4.0/bits/stl_algobase.h:201:2: note: Returning zero (reference to field 'shots')
        return __b;
        ^
./simulator.hpp:195:17: note: Returning from 'min'
      threads = std::min<uint_t>(threads, circ.shots);
                ^
./simulator.hpp:195:7: note: The value 0 is assigned to 'threads'
      threads = std::min<uint_t>(threads, circ.shots);
      ^
./simulator.hpp:196:7: note: Taking false branch
      if (max_threads_shot > 0)
      ^
./simulator.hpp:199:55: note: Division by zero
    uint_t gate_threads = std::max<uint_t>(1UL, ncpus / threads);
                                                      ^
./simulator.hpp:200:30: warning: statement should be inside braces [readability-braces-around-statements]
    if (max_threads_gate > 0)
                             ^
./simulator.hpp:213:43: warning: statement should be inside braces [google-readability-braces-around-statements]
      for (uint_t j = 0; j < threads; ++j)
                                          ^
./simulator.hpp:234:33: warning: statement should be inside braces [readability-braces-around-statements]
      for (auto &&ss : shotseed)
                                ^
./simulator.hpp:243:31: warning: statement should be inside braces [google-readability-braces-around-statements]
      for (auto &&f : futures)
                              ^
./simulator.hpp:262:21: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (threads > 1)
                    ^
./simulator.hpp:275:17: warning: function 'load_qobj_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Simulator::load_qobj_json(const json_t &js) {
                ^
inline 
./simulator.hpp:316:7: warning: use range-based for loop instead [modernize-loop-convert]
      for (auto it = circs.cbegin(); it != circs.cend(); ++it)
      ^
./simulator.hpp:316:63: warning: statement should be inside braces [google-readability-braces-around-statements]
      for (auto it = circs.cbegin(); it != circs.cend(); ++it)
                                                              ^
./simulator.hpp:329:17: warning: function 'check_qobj' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool Simulator::check_qobj(const json_t &qobj) {
                ^
inline 
./simulator.hpp:338:15: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      pass &= JSON::check_key("compiled_circuit", c);
              ^
              static_cast<int>(                     )
./simulator.hpp:340:17: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
        pass &= JSON::check_keys(compiled_keys, c["compiled_circuit"]);
                ^
                static_cast<int>(                                     )
./simulator.hpp:341:18: warning: statement should be inside braces [google-readability-braces-around-statements]
        if (pass)
                 ^
./simulator.hpp:343:15: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
              JSON::check_keys(header_keys, c["compiled_circuit"]["header"]);
              ^
              static_cast<int>(                                             )
./third-party/headers/json.hpp:110:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:63:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:340:1: warning: do not call c-style vararg functions [cppcoreguidelines-pro-type-vararg]
NLOHMANN_JSON_HAS_HELPER(mapped_type);
^
./third-party/headers/json.hpp:228:43: note: expanded from macro 'NLOHMANN_JSON_HAS_HELPER'
                std::is_integral<decltype(detect(std::declval<T>()))>::value; \
                                          ^
./third-party/headers/json.hpp:340:1: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
NLOHMANN_JSON_HAS_HELPER(mapped_type);
^
./third-party/headers/json.hpp:228:50: note: expanded from macro 'NLOHMANN_JSON_HAS_HELPER'
                std::is_integral<decltype(detect(std::declval<T>()))>::value; \
                                                 ^
./third-party/headers/json.hpp:342:1: warning: do not call c-style vararg functions [cppcoreguidelines-pro-type-vararg]
NLOHMANN_JSON_HAS_HELPER(value_type);
^
./third-party/headers/json.hpp:228:43: note: expanded from macro 'NLOHMANN_JSON_HAS_HELPER'
                std::is_integral<decltype(detect(std::declval<T>()))>::value; \
                                          ^
./third-party/headers/json.hpp:343:1: warning: do not call c-style vararg functions [cppcoreguidelines-pro-type-vararg]
NLOHMANN_JSON_HAS_HELPER(iterator);
^
./third-party/headers/json.hpp:228:43: note: expanded from macro 'NLOHMANN_JSON_HAS_HELPER'
                std::is_integral<decltype(detect(std::declval<T>()))>::value; \
                                          ^
./third-party/headers/json.hpp:445:61: warning: do not call c-style vararg functions [cppcoreguidelines-pro-type-vararg]
    static constexpr bool value = std::is_integral<decltype(detect(
                                                            ^
./third-party/headers/json.hpp:490:2: warning: namespace 'detail' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace detail
./third-party/headers/json.hpp:255:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:491:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:245:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:822:2: warning: namespace 'detail' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace detail
./third-party/headers/json.hpp:502:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:823:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:500:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:898:66: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
                                                                 ^
./third-party/headers/json.hpp:898:83: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
                                                                                  ^
./third-party/headers/json.hpp:900:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:835:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:901:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:833:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:1176:83: warning: all parameters should be named in a function [readability-named-parameter]
void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...>)
                                                                                  ^
                                                                                   /*unused*/
./third-party/headers/json.hpp:1219:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:928:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:1224:1: warning: do not use unnamed namespaces in header files [cert-dcl59-cpp]
namespace
^
./third-party/headers/json.hpp:1226:23: warning: variable 'from_json' defined in a header file; variable definitions in header files can lead to ODR violations [misc-definitions-in-headers]
constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
                      ^
./third-party/headers/json.hpp:1227:2: warning: anonymous namespace not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace
./third-party/headers/json.hpp:1225:1: note: anonymous namespace starts here
{
^
./third-party/headers/json.hpp:1228:2: warning: namespace 'nlohmann' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace nlohmann
./third-party/headers/json.hpp:926:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:1351:19: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
                  ^
./third-party/headers/json.hpp:1407:19: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
                  ^
./third-party/headers/json.hpp:1427:57: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    external_constructor<value_t::string>::construct(j, s);
                                                        ^
./third-party/headers/json.hpp:1520:81: warning: all parameters should be named in a function [readability-named-parameter]
void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...>)
                                                                                ^
                                                                                 /*unused*/
./third-party/headers/json.hpp:1563:2: warning: namespace 'detail' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace detail
./third-party/headers/json.hpp:1248:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:1566:1: warning: do not use unnamed namespaces in header files [cert-dcl59-cpp]
namespace
^
./third-party/headers/json.hpp:1568:23: warning: variable 'to_json' defined in a header file; variable definitions in header files can lead to ODR violations [misc-definitions-in-headers]
constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
                      ^
./third-party/headers/json.hpp:1569:2: warning: anonymous namespace not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace
./third-party/headers/json.hpp:1567:1: note: anonymous namespace starts here
{
^
./third-party/headers/json.hpp:1570:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:1246:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:1647:18: warning: Call Path : get_character
Call virtual functions during construction or destruction will never go to a more derived class [clang-analyzer-alpha.cplusplus.VirtualCall]
        if ((c = get_character()) == 0xEF)
                 ^
./third-party/headers/json.hpp:1647:18: note: Call Path : get_characterCall virtual functions during construction or destruction will never go to a more derived class
        if ((c = get_character()) == 0xEF)
                 ^
./third-party/headers/json.hpp:1649:22: warning: Call Path : get_character
Call virtual functions during construction or destruction will never go to a more derived class [clang-analyzer-alpha.cplusplus.VirtualCall]
            if ((c = get_character()) == 0xBB)
                     ^
./third-party/headers/json.hpp:1649:22: note: Call Path : get_characterCall virtual functions during construction or destruction will never go to a more derived class
            if ((c = get_character()) == 0xBB)
                     ^
./third-party/headers/json.hpp:1651:26: warning: Call Path : get_character
Call virtual functions during construction or destruction will never go to a more derived class [clang-analyzer-alpha.cplusplus.VirtualCall]
                if ((c = get_character()) == 0xBF)
                         ^
./third-party/headers/json.hpp:1651:26: note: Call Path : get_characterCall virtual functions during construction or destruction will never go to a more derived class
                if ((c = get_character()) == 0xBF)
                         ^
./third-party/headers/json.hpp:1655:17: warning: don't use else after return [readability-else-after-return]
                else if (c != std::char_traits<char>::eof())
                ^
./third-party/headers/json.hpp:1701:30: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        : cursor(b), limit(b + l), start(b)
                             ^
./third-party/headers/json.hpp:1704:24: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF')
                       ^
./third-party/headers/json.hpp:1704:43: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF')
                                          ^
./third-party/headers/json.hpp:1704:62: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF')
                                                             ^
./third-party/headers/json.hpp:1706:20: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
            cursor += 3;
                   ^
./third-party/headers/json.hpp:1718:64: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
            return std::char_traits<char>::to_int_type(*(cursor++));
                                                               ^
./third-party/headers/json.hpp:1728:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
            --cursor;
            ^
./third-party/headers/json.hpp:1747:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    input_adapter(std::istream& i)
    ^
    explicit 
./third-party/headers/json.hpp:1751:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    input_adapter(std::istream&& i)
    ^
    explicit 
./third-party/headers/json.hpp:1762:53: warning: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast]
        : ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l)) {}
                                                    ^
./third-party/headers/json.hpp:1773:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    input_adapter(CharT b)
    ^
    explicit 
./third-party/headers/json.hpp:1774:25: warning: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast]
        : input_adapter(reinterpret_cast<const char*>(b),
                        ^
./third-party/headers/json.hpp:1775:37: warning: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast]
                        std::strlen(reinterpret_cast<const char*>(b))) {}
                                    ^
./third-party/headers/json.hpp:1786:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(std::accumulate(
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:1786:9: warning: found assert() with side effect [misc-assert-side-effect]
        assert(std::accumulate(
        ^
/usr/include/assert.h:89:4: note: expanded from macro 'assert'
  ((expr)                                                               \
   ^
./third-party/headers/json.hpp:1786:16: warning: side effects in the 1st macro argument 'expr' are repeated in macro expansion [misc-macro-repeated-side-effects]
        assert(std::accumulate(
               ^
/usr/include/assert.h:88:10: note: macro 'assert' defined here
# define assert(expr)                                                   \
         ^
./third-party/headers/json.hpp:1803:57: warning: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast]
            ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
                                                        ^
./third-party/headers/json.hpp:1814:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    input_adapter(T (&array)[N])
    ^
    explicit 
./third-party/headers/json.hpp:1822:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    input_adapter(const ContiguousContainer& c)
    ^
    explicit 
./third-party/headers/json.hpp:1834:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:1594:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:1835:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:1592:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:1844:1: warning: #includes are not sorted properly [llvm-include-order]
#include <ios> // hex, uppercase
^
./third-party/headers/json.hpp:1956:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(loc != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:1982:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(current == 'u');
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2008:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(0x0000 <= codepoint and codepoint <= 0xFFFF);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2029:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2070:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(current == '\"');
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2190:29: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                            assert(0x00 <= codepoint and codepoint <= 0x10FFFF);
                            ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2591:17: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                assert(false); // LCOV_EXCL_LINE
                ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2839:13: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
            assert(endptr == token_buffer.data() + token_buffer.size());
            ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2839:50: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
            assert(endptr == token_buffer.data() + token_buffer.size());
                                                 ^
./third-party/headers/json.hpp:2855:13: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
            assert(endptr == token_buffer.data() + token_buffer.size());
            ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2855:50: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
            assert(endptr == token_buffer.data() + token_buffer.size());
                                                 ^
./third-party/headers/json.hpp:2872:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(endptr == token_buffer.data() + token_buffer.size());
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2872:46: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        assert(endptr == token_buffer.data() + token_buffer.size());
                                             ^
./third-party/headers/json.hpp:2885:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(current == literal_text[0]);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2885:27: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        assert(current == literal_text[0]);
                          ^
./third-party/headers/json.hpp:2888:40: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
            if (JSON_UNLIKELY(get() != literal_text[i]))
                                       ^
./third-party/headers/json.hpp:2937:13: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
            assert(token_string.size() != 0);
            ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:2937:20: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty]
            assert(token_string.size() != 0);
                   ^
                   !token_string.empty()
/usr/include/assert.h:89:5: note: expanded from macro 'assert'
  ((expr)                                                               \
    ^
./third-party/headers/json.hpp:3115:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:1857:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:3116:2: warning: namespace 'nlohmann' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace nlohmann
./third-party/headers/json.hpp:1855:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:3258:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(not errored);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:3263:28: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            result.m_value.destroy(result.m_type);
                           ^
./third-party/headers/json.hpp:3294:40: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        result.m_value.destroy(result.m_type);
                                       ^
./third-party/headers/json.hpp:3335:35: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    value.m_value.destroy(value.m_type);
                                  ^
./third-party/headers/json.hpp:3346:40: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        result.m_value.object->emplace(std::move(key), std::move(value));
                                       ^
./third-party/headers/json.hpp:3367:36: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    result.m_value.destroy(result.m_type);
                                   ^
./third-party/headers/json.hpp:3398:40: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        result.m_value.destroy(result.m_type);
                                       ^
./third-party/headers/json.hpp:3409:35: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    value.m_value.destroy(value.m_type);
                                  ^
./third-party/headers/json.hpp:3420:40: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        result.m_value.array->push_back(std::move(value));
                                       ^
./third-party/headers/json.hpp:3441:36: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    result.m_value.destroy(result.m_type);
                                   ^
./third-party/headers/json.hpp:3494:68: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                if (JSON_UNLIKELY(not std::isfinite(result.m_value.number_float)))
                                                                   ^
./third-party/headers/json.hpp:3711:2: warning: namespace 'detail' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace detail
./third-party/headers/json.hpp:3141:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:3712:2: warning: namespace 'nlohmann' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace nlohmann
./third-party/headers/json.hpp:3139:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:3833:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:3722:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:3834:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:3720:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:3861:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:3844:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:3862:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:3842:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:3959:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:3997:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
    ^
    explicit 
./third-party/headers/json.hpp:4020:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4026:58: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_it.object_iterator = m_object->m_value.object->begin();
                                                         ^
./third-party/headers/json.hpp:4032:57: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_it.array_iterator = m_object->m_value.array->begin();
                                                        ^
./third-party/headers/json.hpp:4057:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4063:58: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_it.object_iterator = m_object->m_value.object->end();
                                                         ^
./third-party/headers/json.hpp:4069:57: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_it.array_iterator = m_object->m_value.array->end();
                                                        ^
./third-party/headers/json.hpp:4088:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4094:17: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                assert(m_it.object_iterator != m_object->m_value.object->end());
                ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4094:66: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                assert(m_it.object_iterator != m_object->m_value.object->end());
                                                                 ^
./third-party/headers/json.hpp:4100:17: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                assert(m_it.array_iterator != m_object->m_value.array->end());
                ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4100:65: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                assert(m_it.array_iterator != m_object->m_value.array->end());
                                                                ^
./third-party/headers/json.hpp:4125:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4131:17: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                assert(m_it.object_iterator != m_object->m_value.object->end());
                ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4131:66: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                assert(m_it.object_iterator != m_object->m_value.object->end());
                                                                 ^
./third-party/headers/json.hpp:4137:17: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                assert(m_it.array_iterator != m_object->m_value.array->end());
                ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4137:65: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                assert(m_it.array_iterator != m_object->m_value.array->end());
                                                                ^
./third-party/headers/json.hpp:4170:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4251:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4458:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:4483:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:3886:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:4484:2: warning: namespace 'nlohmann' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace nlohmann
./third-party/headers/json.hpp:3884:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:4584:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:4497:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:4585:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:4495:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:4631:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
    ^
    explicit 
./third-party/headers/json.hpp:4635:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
    ^
    explicit 
./third-party/headers/json.hpp:4705:2: warning: namespace 'detail' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace detail
./third-party/headers/json.hpp:4596:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:4706:2: warning: namespace 'nlohmann' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace nlohmann
./third-party/headers/json.hpp:4594:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:4803:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    output_adapter(std::vector<CharType>& vec)
    ^
    explicit 
./third-party/headers/json.hpp:4806:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    output_adapter(std::basic_ostream<CharType>& s)
    ^
    explicit 
./third-party/headers/json.hpp:4809:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    output_adapter(std::basic_string<CharType>& s)
    ^
    explicit 
./third-party/headers/json.hpp:4820:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:4722:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:4821:2: warning: namespace 'nlohmann' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace nlohmann
./third-party/headers/json.hpp:4720:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:4951:18: warning: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast]
        return (*reinterpret_cast<char*>(&num) == 1);
                 ^
./third-party/headers/json.hpp:5945:21: warning: missing username/bug in TODO [google-readability-todo]
            get();  // TODO: may we ignore N here?
                    ^
                    // TODO(jgomez): may we ignore N here?
./third-party/headers/json.hpp:6200:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:4852:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:6201:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:4850:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:6397:21: warning: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast]
                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
                    ^
./third-party/headers/json.hpp:6654:21: warning: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast]
                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
                    ^
./third-party/headers/json.hpp:6747:32: warning: statement should be inside braces [readability-braces-around-statements]
                if (add_prefix)
                               ^
./third-party/headers/json.hpp:6780:21: warning: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast]
                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
                    ^
./third-party/headers/json.hpp:6866:25: warning: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast]
                        reinterpret_cast<const CharType*>(el.first.c_str()),
                        ^
./third-party/headers/json.hpp:7047:17: warning: don't use else after return [readability-else-after-return]
                else if ((std::numeric_limits<uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())
                ^
./third-party/headers/json.hpp:7071:17: warning: don't use else after return [readability-else-after-return]
                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
                ^
./third-party/headers/json.hpp:7113:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:6219:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:7114:2: warning: namespace 'nlohmann' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace nlohmann
./third-party/headers/json.hpp:6217:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:7131:1: warning: #includes are not sorted properly [llvm-include-order]
#include <string> // string
^
./third-party/headers/json.hpp:7199:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(x.e == y.e);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7200:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(x.f >= y.f);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7276:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(x.f != 0);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7295:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(delta >= 0);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7296:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(((x.f << delta) >> delta) == x.f);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7318:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(std::isfinite(value));
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7319:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(value > 0);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7598:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(e >= -1500);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7599:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(e <=  1500);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7601:45: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    const int k = (f * 78913) / (1 << 18) + (f > 0);
                                            ^
                                            static_cast<int>
./third-party/headers/json.hpp:7604:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(index >= 0);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7605:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(index < kCachedPowersSize);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7608:33: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    const cached_power cached = kCachedPowers[index];
                                ^
./third-party/headers/json.hpp:7609:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(kAlpha <= cached.e + e + 64);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7610:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(kGamma >= cached.e + e + 64);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7628:5: warning: don't use else after return [readability-else-after-return]
    else if (n >= 100000000)
    ^
./third-party/headers/json.hpp:7678:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(len >= 1);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7679:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(dist <= delta);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7680:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(rest <= delta);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7681:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(ten_k > 0);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7706:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(buf[len - 1] != '0');
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7706:16: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        assert(buf[len - 1] != '0');
               ^
./third-party/headers/json.hpp:7707:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buf[len - 1]--;
        ^
./third-party/headers/json.hpp:7734:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(M_plus.e >= kAlpha);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7735:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(M_plus.e <= kGamma);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7756:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(p1 > 0);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7792:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(d <= 9);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7793:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
        ^
./third-party/headers/json.hpp:7879:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(p2 > delta);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7890:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(p2 <= UINT64_MAX / 10);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7899:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(d <= 9);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7900:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
        ^
./third-party/headers/json.hpp:7959:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(m_plus.e == m_minus.e);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:7960:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(m_plus.e == v.e);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8020:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(std::isfinite(value));
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8021:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(value > 0);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8055:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(e > -1000);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8056:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(e <  1000);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8061:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *buf++ = '-';
            ^
./third-party/headers/json.hpp:8065:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *buf++ = '+';
            ^
./third-party/headers/json.hpp:8073:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *buf++ = '0';
            ^
./third-party/headers/json.hpp:8074:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *buf++ = static_cast<char>('0' + k);
            ^
./third-party/headers/json.hpp:8078:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *buf++ = static_cast<char>('0' + k / 10);
            ^
./third-party/headers/json.hpp:8080:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *buf++ = static_cast<char>('0' + k);
            ^
./third-party/headers/json.hpp:8084:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *buf++ = static_cast<char>('0' + k / 100);
            ^
./third-party/headers/json.hpp:8086:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *buf++ = static_cast<char>('0' + k / 10);
            ^
./third-party/headers/json.hpp:8088:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *buf++ = static_cast<char>('0' + k);
            ^
./third-party/headers/json.hpp:8106:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(min_exp < 0);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8107:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(max_exp > 0);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8121:25: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        std::memset(buf + k, '0', static_cast<size_t>(n - k));
                        ^
./third-party/headers/json.hpp:8123:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buf[n + 0] = '.';
        ^
./third-party/headers/json.hpp:8124:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buf[n + 1] = '0';
        ^
./third-party/headers/json.hpp:8125:20: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        return buf + (n + 2);
                   ^
./third-party/headers/json.hpp:8133:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(k > n);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8135:26: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        std::memmove(buf + (n + 1), buf + n, static_cast<size_t>(k - n));
                         ^
./third-party/headers/json.hpp:8135:41: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        std::memmove(buf + (n + 1), buf + n, static_cast<size_t>(k - n));
                                        ^
./third-party/headers/json.hpp:8136:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buf[n] = '.';
        ^
./third-party/headers/json.hpp:8137:20: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        return buf + (k + 1);
                   ^
./third-party/headers/json.hpp:8145:26: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        std::memmove(buf + (2 + -n), buf, static_cast<size_t>(k));
                         ^
./third-party/headers/json.hpp:8146:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buf[0] = '0';
        ^
./third-party/headers/json.hpp:8147:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buf[1] = '.';
        ^
./third-party/headers/json.hpp:8148:25: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        std::memset(buf + 2, '0', static_cast<size_t>(-n));
                        ^
./third-party/headers/json.hpp:8149:20: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        return buf + (2 + (-n) + k);
                   ^
./third-party/headers/json.hpp:8157:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buf += 1;
            ^
./third-party/headers/json.hpp:8164:26: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k - 1));
                         ^
./third-party/headers/json.hpp:8164:35: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k - 1));
                                  ^
./third-party/headers/json.hpp:8165:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buf[1] = '.';
        ^
./third-party/headers/json.hpp:8166:13: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        buf += 1 + k;
            ^
./third-party/headers/json.hpp:8169:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    *buf++ = 'e';
        ^
./third-party/headers/json.hpp:8189:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(std::isfinite(value));
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8195:15: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *first++ = '-';
              ^
./third-party/headers/json.hpp:8200:15: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *first++ = '0';
              ^
./third-party/headers/json.hpp:8202:15: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *first++ = '.';
              ^
./third-party/headers/json.hpp:8203:15: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        *first++ = '0';
              ^
./third-party/headers/json.hpp:8207:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(last - first >= std::numeric_limits<FloatType>::max_digits10);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8217:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(len <= std::numeric_limits<FloatType>::max_digits10);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8224:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(last - first >= kMaxExp + 2);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8225:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8226:5: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
    assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8303:33: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                if (val.m_value.object->empty())
                                ^
./third-party/headers/json.hpp:8321:42: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    auto i = val.m_value.object->cbegin();
                                         ^
./third-party/headers/json.hpp:8322:65: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
                                                                ^
./third-party/headers/json.hpp:8333:21: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                    assert(i != val.m_value.object->cend());
                    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8333:45: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    assert(i != val.m_value.object->cend());
                                            ^
./third-party/headers/json.hpp:8334:21: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                    assert(std::next(i) == val.m_value.object->cend());
                    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8334:56: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    assert(std::next(i) == val.m_value.object->cend());
                                                       ^
./third-party/headers/json.hpp:8350:42: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    auto i = val.m_value.object->cbegin();
                                         ^
./third-party/headers/json.hpp:8351:65: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
                                                                ^
./third-party/headers/json.hpp:8361:21: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                    assert(i != val.m_value.object->cend());
                    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8361:45: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    assert(i != val.m_value.object->cend());
                                            ^
./third-party/headers/json.hpp:8362:21: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                    assert(std::next(i) == val.m_value.object->cend());
                    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8362:56: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    assert(std::next(i) == val.m_value.object->cend());
                                                       ^
./third-party/headers/json.hpp:8376:33: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                if (val.m_value.array->empty())
                                ^
./third-party/headers/json.hpp:8390:51: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        for (auto i = val.m_value.array->cbegin();
                                                  ^
./third-party/headers/json.hpp:8391:50: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                                i != val.m_value.array->cend() - 1; ++i)
                                                 ^
./third-party/headers/json.hpp:8398:25: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                        assert(not val.m_value.array->empty());
                        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8398:48: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        assert(not val.m_value.array->empty());
                                               ^
./third-party/headers/json.hpp:8399:42: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        dump(val.m_value.array->back(), true, ensure_ascii, indent_step, current_indent);
                                         ^
./third-party/headers/json.hpp:8415:51: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        for (auto i = val.m_value.array->cbegin();
                                                  ^
./third-party/headers/json.hpp:8416:50: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                                i != val.m_value.array->cend() - 1; ++i)
                                                 ^
./third-party/headers/json.hpp:8424:25: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                        assert(not val.m_value.array->empty());
                        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8424:48: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        assert(not val.m_value.array->empty());
                                               ^
./third-party/headers/json.hpp:8426:42: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                        dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
                                         ^
./third-party/headers/json.hpp:8438:47: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    for (auto i = val.m_value.array->cbegin();
                                              ^
./third-party/headers/json.hpp:8439:46: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                            i != val.m_value.array->cend() - 1; ++i)
                                             ^
./third-party/headers/json.hpp:8446:21: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                    assert(not val.m_value.array->empty());
                    ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8446:44: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    assert(not val.m_value.array->empty());
                                           ^
./third-party/headers/json.hpp:8447:38: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
                                     ^
./third-party/headers/json.hpp:8458:43: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                dump_escaped(*val.m_value.string, ensure_ascii);
                                          ^
./third-party/headers/json.hpp:8465:33: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                if (val.m_value.boolean)
                                ^
./third-party/headers/json.hpp:8478:42: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                dump_integer(val.m_value.number_integer);
                                         ^
./third-party/headers/json.hpp:8484:42: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                dump_integer(val.m_value.number_unsigned);
                                         ^
./third-party/headers/json.hpp:8490:40: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                dump_float(val.m_value.number_float);
                                       ^
./third-party/headers/json.hpp:8541:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = '\\';
                            ^
./third-party/headers/json.hpp:8542:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = 'b';
                            ^
./third-party/headers/json.hpp:8548:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = '\\';
                            ^
./third-party/headers/json.hpp:8549:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = 't';
                            ^
./third-party/headers/json.hpp:8555:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = '\\';
                            ^
./third-party/headers/json.hpp:8556:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = 'n';
                            ^
./third-party/headers/json.hpp:8562:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = '\\';
                            ^
./third-party/headers/json.hpp:8563:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = 'f';
                            ^
./third-party/headers/json.hpp:8569:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = '\\';
                            ^
./third-party/headers/json.hpp:8570:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = 'r';
                            ^
./third-party/headers/json.hpp:8576:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = '\\';
                            ^
./third-party/headers/json.hpp:8577:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = '\"';
                            ^
./third-party/headers/json.hpp:8583:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = '\\';
                            ^
./third-party/headers/json.hpp:8584:29: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                            string_buffer[bytes++] = '\\';
                            ^
./third-party/headers/json.hpp:8596:37: warning: do not call c-style vararg functions [cppcoreguidelines-pro-type-vararg]
                                    std::snprintf(string_buffer.data() + bytes, 7, "\\u%04x",
                                    ^
./third-party/headers/json.hpp:8602:37: warning: do not call c-style vararg functions [cppcoreguidelines-pro-type-vararg]
                                    std::snprintf(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
                                    ^
./third-party/headers/json.hpp:8612:33: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                                string_buffer[bytes++] = s[i];
                                ^
./third-party/headers/json.hpp:8641:25: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
                        string_buffer[bytes++] = s[i];
                        ^
./third-party/headers/json.hpp:8693:13: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
            assert(i < number_buffer.size() - 1);
            ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8695:54: warning: consider replacing 'long' with 'int64' [google-runtime-int]
            const auto digit = std::labs(static_cast<long>(x % 10));
                                                     ^
./third-party/headers/json.hpp:8696:13: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
            number_buffer[i++] = static_cast<char>('0' + digit);
            ^
./third-party/headers/json.hpp:8703:13: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
            assert(i < number_buffer.size() - 2);
            ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:8704:13: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
            number_buffer[i++] = '-';
            ^
./third-party/headers/json.hpp:8743:63: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
                                                              ^
./third-party/headers/json.hpp:8840:30: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        const uint8_t type = utf8d[byte];
                             ^
./third-party/headers/json.hpp:8846:17: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        state = utf8d[256u + state * 16u + type];
                ^
./third-party/headers/json.hpp:8872:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:8245:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:8873:2: warning: namespace 'nlohmann' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace nlohmann
./third-party/headers/json.hpp:8243:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:8891:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    json_ref(value_type&& value)
    ^
    explicit 
./third-party/headers/json.hpp:8895:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    json_ref(const value_type& value)
    ^
    explicit 
./third-party/headers/json.hpp:8896:21: warning: do not use const_cast [cppcoreguidelines-pro-type-const-cast]
        : value_ref(const_cast<value_type*>(&value)), is_rvalue(false)
                    ^
./third-party/headers/json.hpp:8904:5: warning: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    json_ref(Args&& ... args)
    ^
    explicit 
./third-party/headers/json.hpp:8909:5: warning: move constructors should be marked noexcept [misc-noexcept-move-constructor]
    json_ref(json_ref&&) = default;
    ^
./third-party/headers/json.hpp:8937:2: warning: namespace 'detail' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace detail
./third-party/headers/json.hpp:8883:11: note: namespace 'detail' starts here
namespace detail
          ^
./third-party/headers/json.hpp:8938:2: warning: namespace 'nlohmann' not terminated with a closing comment [llvm-namespace-comment]
}
 ^
  // namespace nlohmann
./third-party/headers/json.hpp:8881:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:9469:17: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
                assert(reference_token[pos] == '~');
                ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:9504:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(not f.empty());
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:9639:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:8955:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:9688:2: warning: namespace 'nlohmann' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace nlohmann
./third-party/headers/json.hpp:9651:11: note: namespace 'nlohmann' starts here
namespace nlohmann
          ^
./third-party/headers/json.hpp:9932:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["copyright"] = "(C) 2013-2017 Niels Lohmann";
               ^
./third-party/headers/json.hpp:9933:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["name"] = "JSON for Modern C++";
               ^
./third-party/headers/json.hpp:9934:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["url"] = "https://github.com/nlohmann/json";
               ^
./third-party/headers/json.hpp:9935:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["version"]["string"] =
               ^
./third-party/headers/json.hpp:9935:27: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["version"]["string"] =
                          ^
./third-party/headers/json.hpp:9939:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
               ^
./third-party/headers/json.hpp:9939:27: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
                          ^
./third-party/headers/json.hpp:9940:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
               ^
./third-party/headers/json.hpp:9940:27: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
                          ^
./third-party/headers/json.hpp:9941:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
               ^
./third-party/headers/json.hpp:9941:27: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
                          ^
./third-party/headers/json.hpp:9946:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["platform"] = "linux";
               ^
./third-party/headers/json.hpp:9958:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
               ^
./third-party/headers/json.hpp:9976:16: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["compiler"]["c++"] = std::to_string(__cplusplus);
               ^
./third-party/headers/json.hpp:9976:28: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        result["compiler"]["c++"] = std::to_string(__cplusplus);
                           ^
./third-party/headers/json.hpp:10443:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:10495:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(boolean_t v) noexcept : boolean(v) {}
        ^
        explicit 
./third-party/headers/json.hpp:10497:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(number_integer_t v) noexcept : number_integer(v) {}
        ^
        explicit 
./third-party/headers/json.hpp:10499:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
        ^
        explicit 
./third-party/headers/json.hpp:10501:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(number_float_t v) noexcept : number_float(v) {}
        ^
        explicit 
./third-party/headers/json.hpp:10503:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(value_t t)
        ^
        explicit 
./third-party/headers/json.hpp:10568:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(const string_t& value)
        ^
        explicit 
./third-party/headers/json.hpp:10574:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(string_t&& value)
        ^
        explicit 
./third-party/headers/json.hpp:10580:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(const object_t& value)
        ^
        explicit 
./third-party/headers/json.hpp:10586:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(object_t&& value)
        ^
        explicit 
./third-party/headers/json.hpp:10592:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(const array_t& value)
        ^
        explicit 
./third-party/headers/json.hpp:10598:9: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
        json_value(array_t&& value)
        ^
        explicit 
./third-party/headers/json.hpp:10650:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_type != value_t::object or m_value.object != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:10650:53: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        assert(m_type != value_t::object or m_value.object != nullptr);
                                                    ^
./third-party/headers/json.hpp:10651:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_type != value_t::array or m_value.array != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:10651:52: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        assert(m_type != value_t::array or m_value.array != nullptr);
                                                   ^
./third-party/headers/json.hpp:10652:9: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
        assert(m_type != value_t::string or m_value.string != nullptr);
        ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:10652:53: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        assert(m_type != value_t::string or m_value.string != nullptr);
                                                    ^
./third-party/headers/json.hpp:10767:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    basic_json(const value_t v)
    ^
    explicit 
./third-party/headers/json.hpp:10791:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    basic_json(std::nullptr_t = nullptr) noexcept
    ^
    explicit 
./third-party/headers/json.hpp:10857:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    basic_json(CompatibleType && val) noexcept(noexcept(
    ^
    explicit 
./third-party/headers/json.hpp:11258:5: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
    basic_json(const detail::json_ref<basic_json>& ref)
    ^
    explicit 
./third-party/headers/json.hpp:11297:42: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_value = *other.m_value.object;
                                         ^
./third-party/headers/json.hpp:11303:42: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_value = *other.m_value.array;
                                         ^
./third-party/headers/json.hpp:11309:42: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_value = *other.m_value.string;
                                         ^
./third-party/headers/json.hpp:11315:41: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_value = other.m_value.boolean;
                                        ^
./third-party/headers/json.hpp:11321:41: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_value = other.m_value.number_integer;
                                        ^
./third-party/headers/json.hpp:11327:41: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_value = other.m_value.number_unsigned;
                                        ^
./third-party/headers/json.hpp:11333:41: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_value = other.m_value.number_float;
                                        ^
./third-party/headers/json.hpp:11408:60: warning: identical expressions on both sides of logical operator [clang-analyzer-alpha.core.IdenticalExpr]
        std::is_nothrow_move_constructible<value_t>::value and
                                                           ^
./third-party/headers/json.hpp:11408:60: note: identical expressions on both sides of logical operator
        std::is_nothrow_move_constructible<value_t>::value and
                                                           ^
./third-party/headers/json.hpp:11443:17: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        m_value.destroy(m_type);
                ^
./third-party/headers/json.hpp:11934:38: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        return is_string() ? m_value.string : nullptr;
                                     ^
./third-party/headers/json.hpp:11946:40: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        return is_boolean() ? &m_value.boolean : nullptr;
                                       ^
./third-party/headers/json.hpp:11958:47: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        return is_number_integer() ? &m_value.number_integer : nullptr;
                                              ^
./third-party/headers/json.hpp:11970:48: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
                                               ^
./third-party/headers/json.hpp:11982:45: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        return is_number_float() ? &m_value.number_float : nullptr;
                                            ^
./third-party/headers/json.hpp:12253:13: warning: identical expressions on both sides of logical operator [clang-analyzer-alpha.core.IdenticalExpr]
            or std::is_same<array_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12253:13: note: identical expressions on both sides of logical operator
            or std::is_same<array_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12254:13: warning: identical expressions on both sides of logical operator [clang-analyzer-alpha.core.IdenticalExpr]
            or std::is_same<string_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12254:13: note: identical expressions on both sides of logical operator
            or std::is_same<string_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12255:13: warning: identical expressions on both sides of logical operator [clang-analyzer-alpha.core.IdenticalExpr]
            or std::is_same<boolean_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12255:13: note: identical expressions on both sides of logical operator
            or std::is_same<boolean_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12256:13: warning: identical expressions on both sides of logical operator [clang-analyzer-alpha.core.IdenticalExpr]
            or std::is_same<number_integer_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12256:13: note: identical expressions on both sides of logical operator
            or std::is_same<number_integer_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12257:13: warning: identical expressions on both sides of logical operator [clang-analyzer-alpha.core.IdenticalExpr]
            or std::is_same<number_unsigned_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12257:13: note: identical expressions on both sides of logical operator
            or std::is_same<number_unsigned_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12258:13: warning: identical expressions on both sides of logical operator [clang-analyzer-alpha.core.IdenticalExpr]
            or std::is_same<number_float_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12258:13: note: identical expressions on both sides of logical operator
            or std::is_same<number_float_t, pointee_t>::value
            ^
./third-party/headers/json.hpp:12551:32: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                return m_value.object->at(key);
                               ^
./third-party/headers/json.hpp:12596:21: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            m_value.array = create<array_t>();
                    ^
./third-party/headers/json.hpp:12604:32: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            if (idx >= m_value.array->size())
                               ^
./third-party/headers/json.hpp:12606:25: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_value.array->insert(m_value.array->end(),
                        ^
./third-party/headers/json.hpp:12606:47: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                m_value.array->insert(m_value.array->end(),
                                              ^
./third-party/headers/json.hpp:12607:53: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                                      idx - m_value.array->size() + 1,
                                                    ^
./third-party/headers/json.hpp:12611:28: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            return m_value.array->operator[](idx);
                           ^
./third-party/headers/json.hpp:12641:28: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            return m_value.array->operator[](idx);
                           ^
./third-party/headers/json.hpp:12680:21: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            m_value.object = create<object_t>();
                    ^
./third-party/headers/json.hpp:12687:28: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            return m_value.object->operator[](key);
                           ^
./third-party/headers/json.hpp:12728:13: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
            assert(m_value.object->find(key) != m_value.object->end());
            ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:12728:28: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            assert(m_value.object->find(key) != m_value.object->end());
                           ^
./third-party/headers/json.hpp:12728:57: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            assert(m_value.object->find(key) != m_value.object->end());
                                                        ^
./third-party/headers/json.hpp:12729:28: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            return m_value.object->find(key)->second;
                           ^
./third-party/headers/json.hpp:12776:28: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            return m_value.object->operator[](key);
                           ^
./third-party/headers/json.hpp:12818:13: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
            assert(m_value.object->find(key) != m_value.object->end());
            ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./third-party/headers/json.hpp:12818:28: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            assert(m_value.object->find(key) != m_value.object->end());
                           ^
./third-party/headers/json.hpp:12818:57: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            assert(m_value.object->find(key) != m_value.object->end());
                                                        ^
./third-party/headers/json.hpp:12819:28: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            return m_value.object->find(key)->second;
                           ^
./third-party/headers/json.hpp:13410:51: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
                                                  ^
./third-party/headers/json.hpp:13929:32: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                return m_value.array->empty();
                               ^
./third-party/headers/json.hpp:13935:32: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                return m_value.object->empty();
                               ^
./third-party/headers/json.hpp:14001:32: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                return m_value.array->size();
                               ^
./third-party/headers/json.hpp:14007:32: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
                return m_value.object->size();
                               ^
./third-party/headers/json.hpp:14216:17: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        m_value.array->push_back(std::move(val));
                ^
./third-party/headers/json.hpp:14252:17: warning: do not access members of unions; use (boost::)variant instead [cppcoreguidelines-pro-type-union-access]
        m_value.array->push_back(val);
                ^
./third-party/headers/json.hpp:14831:60: warning: identical expressions on both sides of logical operator [clang-analyzer-alpha.core.IdenticalExpr]
        std::is_nothrow_move_constructible<value_t>::value and
                                                           ^
./third-party/headers/json.hpp:14831:60: note: identical expressions on both sides of logical operator
        std::is_nothrow_move_constructible<value_t>::value and
                                                           ^
./third-party/headers/json.hpp:17106:13: warning: function template specialization 'std::swap<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char>, bool, long, unsigned long, double, std::allocator, adl_serializer> >' has a primary template declaration with different parameter names [readability-inconsistent-declaration-parameter-name]
inline void swap(nlohmann::json& j1,
            ^
/usr/lib/gcc/x86_64-linux-gnu/5.4.0/../../../../include/c++/5.4.0/bits/move.h:176:5: note: the primary template declaration seen here
    swap(_Tp& __a, _Tp& __b)
    ^
./third-party/headers/json.hpp:17106:13: note: differing parameters are named here: ('j1', 'j2'), in primary template declaration: ('__a', '__b')
inline void swap(nlohmann::json& j1,
            ^
./third-party/headers/json.hpp:17108:75: warning: identical expressions on both sides of logical operator [clang-analyzer-alpha.core.IdenticalExpr]
                     is_nothrow_move_constructible<nlohmann::json>::value and
                                                                          ^
./third-party/headers/json.hpp:17108:75: note: identical expressions on both sides of logical operator
                     is_nothrow_move_constructible<nlohmann::json>::value and
                                                                          ^
./third-party/headers/json.hpp:17166:39: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    return nlohmann::json::parse(s, s + n);
                                      ^
./utilities/binary_vector.hpp:26:1: warning: #includes are not sorted properly [llvm-include-order]
#include <stdexcept>
^
./utilities/binary_vector.hpp:34:18: warning: consider replacing 'unsigned long long' with 'uint64' [google-runtime-int]
  using uint_t = unsigned long long;
                 ^
./utilities/binary_vector.hpp:51:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  BinaryVector(uint_t length)
  ^
  explicit 
./utilities/binary_vector.hpp:54:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  BinaryVector(std::vector<uint_t> mdata)
  ^
  explicit 
./utilities/binary_vector.hpp:57:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  BinaryVector(std::string);
  ^
  explicit 
./utilities/binary_vector.hpp:57:27: warning: all parameters should be named in a function [readability-named-parameter]
  BinaryVector(std::string);
                          ^
                           /*val*/
./utilities/binary_vector.hpp:64:36: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
  void set0(uint_t pos) { setValue(0, pos); };
                                   ^
                                   false
./utilities/binary_vector.hpp:65:36: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
  void set1(uint_t pos) { setValue(1, pos); };
                                   ^
                                   true
./utilities/binary_vector.hpp:98:8: warning: consider replacing 'long' with 'int64' [google-runtime-int]
inline long gauss_eliminate(std::vector<BinaryVector> &M,
       ^
./utilities/binary_vector.hpp:99:35: warning: consider replacing 'long' with 'int64' [google-runtime-int]
                            const long start_col = 0)
                                  ^
./utilities/binary_vector.hpp:104:9: warning: consider replacing 'long' with 'int64' [google-runtime-int]
  const long nrows = M.size();
        ^
./utilities/binary_vector.hpp:105:9: warning: consider replacing 'long' with 'int64' [google-runtime-int]
  const long ncols = M.front().getLength();
        ^
./utilities/binary_vector.hpp:106:3: warning: consider replacing 'long' with 'int64' [google-runtime-int]
  long rank = 0;
  ^
./utilities/binary_vector.hpp:107:3: warning: consider replacing 'long' with 'int64' [google-runtime-int]
  long k, r, i;
  ^
./utilities/binary_vector.hpp:111:11: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      if (M[r][k] == 0)
          ^
          static_cast<int>( )
./utilities/binary_vector.hpp:111:24: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (M[r][k] == 0)
                       ^
./utilities/binary_vector.hpp:137:39: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint_t j = 0; j != blocks; ++j)
                                      ^
./utilities/binary_vector.hpp:139:64: warning: use nullptr [modernize-use-nullptr]
        stoull(val.substr(n - (j + 1) * blockSize, blockSize), 0, blockSize));
                                                               ^
                                                               nullptr
./utilities/binary_vector.hpp:140:16: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (tail > 0)
               ^
./utilities/binary_vector.hpp:141:47: warning: use nullptr [modernize-use-nullptr]
    ret.push_back(stoull(val.substr(0, tail), 0, blockSize));
                                              ^
                                              nullptr
./utilities/binary_vector.hpp:147:36: warning: statement should be inside braces [readability-braces-around-statements]
  if (type == "0b" || type == "0B")
                                   ^
./utilities/binary_vector.hpp:150:3: warning: don't use else after return [readability-else-after-return]
  else if (type == "0x" || type == "0X")
  ^
./utilities/binary_vector.hpp:150:41: warning: statement should be inside braces [google-readability-braces-around-statements]
  else if (type == "0x" || type == "0X")
                                        ^
./utilities/binary_vector.hpp:166:15: warning: function 'BinaryVector' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
BinaryVector::BinaryVector(std::string val) {
              ^
inline 
./utilities/binary_vector.hpp:171:20: warning: function 'setLength' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool BinaryVector::setLength(uint_t length) {
                   ^
inline 
./utilities/binary_vector.hpp:172:19: warning: statement should be inside braces [readability-braces-around-statements]
  if (length == 0)
                  ^
./utilities/binary_vector.hpp:174:20: warning: statement should be inside braces [readability-braces-around-statements]
  if (m_length > 0)
                   ^
./utilities/binary_vector.hpp:181:20: warning: function 'setValue' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void BinaryVector::setValue(bool value, uint_t pos) {
                   ^
inline 
./utilities/binary_vector.hpp:184:13: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (value)
            ^
./utilities/binary_vector.hpp:186:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/binary_vector.hpp:190:20: warning: function 'flipAt' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void BinaryVector::flipAt(const uint_t pos) {
                   ^
inline 
./utilities/binary_vector.hpp:196:29: warning: function 'operator+=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
BinaryVector &BinaryVector::operator+=(const BinaryVector &rhs) {
                            ^
inline 
./utilities/binary_vector.hpp:198:36: warning: statement should be inside braces [readability-braces-around-statements]
  for (size_t i = 0; i < size; i++)
                                   ^
./utilities/binary_vector.hpp:203:20: warning: function 'operator[]' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool BinaryVector::operator[](const uint_t pos) const {
                   ^
inline 
./utilities/binary_vector.hpp:209:20: warning: function 'swap' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void BinaryVector::swap(BinaryVector &rhs) {
                   ^
inline 
./utilities/binary_vector.hpp:218:20: warning: function 'isZero' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool BinaryVector::isZero() const {
                   ^
inline 
./utilities/binary_vector.hpp:220:36: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (size_t i = 0; i < size; i++)
                                   ^
./utilities/binary_vector.hpp:221:9: warning: implicit cast 'value_type' -> bool [readability-implicit-bool-cast]
    if (m_data[i])
        ^
                  != 0u
./utilities/binary_vector.hpp:221:19: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (m_data[i])
                  ^
./utilities/binary_vector.hpp:226:20: warning: function 'isSame' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool BinaryVector::isSame(const BinaryVector &rhs) const {
                   ^
inline 
./utilities/binary_vector.hpp:227:32: warning: statement should be inside braces [readability-braces-around-statements]
  if (m_length != rhs.m_length)
                               ^
./utilities/binary_vector.hpp:231:36: warning: statement should be inside braces [readability-braces-around-statements]
    if (m_data[q] != rhs.m_data[q])
                                   ^
./utilities/binary_vector.hpp:237:20: warning: function 'isSame' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool BinaryVector::isSame(const BinaryVector &rhs, bool pad) const {
                   ^
inline 
./utilities/binary_vector.hpp:238:12: warning: statement should be inside braces [readability-braces-around-statements]
  if (!pad)
           ^
./utilities/binary_vector.hpp:240:3: warning: don't use else after return [readability-else-after-return]
  else {
  ^
./utilities/binary_vector.hpp:246:36: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t q = 0; q < sz; q++)
                                   ^
./utilities/binary_vector.hpp:247:38: warning: statement should be inside braces [readability-braces-around-statements]
      if (m_data[q] != rhs.m_data[q])
                                     ^
./utilities/binary_vector.hpp:250:38: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (size_t q = sz; q < sz0; q++)
                                     ^
./utilities/binary_vector.hpp:251:26: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (m_data[q] != 0)
                         ^
./utilities/binary_vector.hpp:253:38: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (size_t q = sz; q < sz1; q++)
                                     ^
./utilities/binary_vector.hpp:254:30: warning: statement should be inside braces [readability-braces-around-statements]
      if (rhs.m_data[q] != 0)
                             ^
./utilities/binary_vector.hpp:261:35: warning: function 'nonzeroIndices' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::vector<uint_t> BinaryVector::nonzeroIndices() const {
                                  ^
inline 
./utilities/binary_vector.hpp:267:30: warning: statement should be inside braces [readability-braces-around-statements]
      if (i == m_data.size())
                             ^
./utilities/binary_vector.hpp:276:26: warning: statement should be inside braces [readability-braces-around-statements]
      if (r >= blockSize)
                         ^
./utilities/binary_vector.hpp:278:24: warning: C-style casts are discouraged; use static_cast [google-readability-casting]
      result.push_back((uint_t)(i)*blockSize + r);
                       ^
                       static_cast<uint_t>
./utilities/circuit.hpp:34:1: warning: #includes are not sorted properly [llvm-include-order]
#include "types.hpp"
^
./utilities/circuit.hpp:111:10: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  inline Circuit(const json_t &circuit) {
         ^
         explicit 
./utilities/circuit.hpp:135:13: warning: function 'QISKIT::Circuit::parse_op' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  operation parse_op(const json_t &js, const gateset_t &gs);
            ^
                                   node
./utilities/circuit.hpp:255:20: note: the definition seen here
operation Circuit::parse_op(const json_t &node, const gateset_t &gs) {
                   ^
./utilities/circuit.hpp:135:13: note: differing parameters are named here: ('js'), in definition: ('node')
  operation parse_op(const json_t &js, const gateset_t &gs);
            ^
./utilities/circuit.hpp:145:11: warning: function 'QISKIT::Circuit::parse_reglist' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  reglist parse_reglist(const json_t &js);
          ^
                                      node
./utilities/circuit.hpp:334:18: note: the definition seen here
reglist Circuit::parse_reglist(const json_t &node) {
                 ^
./utilities/circuit.hpp:145:11: note: differing parameters are named here: ('js'), in definition: ('node')
  reglist parse_reglist(const json_t &js);
          ^
./utilities/circuit.hpp:150:8: warning: function 'QISKIT::Circuit::set_gateid' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  bool set_gateid(operation &op, std::string name, const gateset_t &gs);
       ^
                                             label
./utilities/circuit.hpp:243:15: note: the definition seen here
bool Circuit::set_gateid(operation &op, std::string label,
              ^
./utilities/circuit.hpp:150:8: note: differing parameters are named here: ('name'), in definition: ('label')
  bool set_gateid(operation &op, std::string name, const gateset_t &gs);
       ^
./utilities/circuit.hpp:164:15: warning: function 'parse' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Circuit::parse(const json_t &circuit, const json_t &qobjconf,
              ^
inline 
./utilities/circuit.hpp:181:11: warning: statement should be inside braces [google-readability-braces-around-statements]
    } else
          ^
./utilities/circuit.hpp:196:39: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (const auto &reg : clbit_labels)
                                      ^
./utilities/circuit.hpp:213:19: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (ops.empty())
                  ^
./utilities/circuit.hpp:215:3: warning: use range-based for loop instead [modernize-loop-convert]
  for (auto it = ops.begin(); it != ops.end(); ++it)
  ^
./utilities/circuit.hpp:215:53: warning: statement should be inside braces [readability-braces-around-statements]
  for (auto it = ops.begin(); it != ops.end(); ++it)
                                                    ^
./utilities/circuit.hpp:243:15: warning: function 'set_gateid' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool Circuit::set_gateid(operation &op, std::string label,
              ^
inline 
./utilities/circuit.hpp:250:5: warning: don't use else after return [readability-else-after-return]
  } else
    ^
./utilities/circuit.hpp:250:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  } else
        ^
./utilities/circuit.hpp:255:20: warning: function 'parse_op' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
operation Circuit::parse_op(const json_t &node, const gateset_t &gs) {
                   ^
inline 
./utilities/circuit.hpp:273:27: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (auto q : op.qubits)
                          ^
./utilities/circuit.hpp:278:27: warning: statement should be inside braces [readability-braces-around-statements]
  for (auto q : op.clbits)
                          ^
./utilities/circuit.hpp:305:23: warning: function 'parse_conditional' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
operation_if Circuit::parse_conditional(const json_t &jcond) {
                      ^
inline 
./utilities/circuit.hpp:334:18: warning: function 'parse_reglist' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
reglist Circuit::parse_reglist(const json_t &node) {
                 ^
inline 
./utilities/circuit.hpp:339:5: warning: use range-based for loop instead [modernize-loop-convert]
    for (auto it = node.begin(); it != node.end(); ++it)
    ^
./utilities/circuit.hpp:339:57: warning: statement should be inside braces [readability-braces-around-statements]
    for (auto it = node.begin(); it != node.end(); ++it)
                                                        ^
./utilities/circuit.hpp:350:15: warning: function 'check_opt_meas' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool Circuit::check_opt_meas() {
              ^
inline 
./utilities/circuit.hpp:353:68: warning: statement should be inside braces [readability-braces-around-statements]
  for (auto it = operations.cbegin(); it < operations.cend(); it++)
                                                                   ^
./utilities/circuit.hpp:354:33: warning: statement should be inside braces [readability-braces-around-statements]
    if (it->id == gate_t::Reset)
                                ^
./utilities/circuit.hpp:364:74: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (auto it = operations.cbegin() + pos; it < operations.cend(); it++)
                                                                         ^
./utilities/circuit.hpp:365:13: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    pass &= (it->id == gate_t::Measure);
            ^
            static_cast<int>
./utilities/clifford.hpp:31:1: warning: using declarations in the global namespace in headers are prohibited [google-global-names-in-headers]
using BV::BinaryVector;
^
./utilities/clifford.hpp:32:1: warning: using declarations in the global namespace in headers are prohibited [google-global-names-in-headers]
using BV::uint_t;
^
./utilities/clifford.hpp:44:39: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
  PauliOperator() : X(0), Z(0), phase(0){};
                                      ^
                                      false
./utilities/clifford.hpp:45:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  PauliOperator(uint64_t len) : X(len), Z(len), phase(0) {}
  ^
  explicit 
./utilities/clifford.hpp:45:55: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
  PauliOperator(uint64_t len) : X(len), Z(len), phase(0) {}
                                                      ^
                                                      false
./utilities/clifford.hpp:58:3: warning: function 'Clifford::Clifford' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  Clifford(const uint64_t nqubit);
  ^
                          nq
./utilities/clifford.hpp:108:11: note: the definition seen here
Clifford::Clifford(uint64_t nq) : nqubits(nq) {
          ^
./utilities/clifford.hpp:58:3: note: differing parameters are named here: ('nqubit'), in definition: ('nq')
  Clifford(const uint64_t nqubit);
  ^
./utilities/clifford.hpp:58:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  Clifford(const uint64_t nqubit);
  ^
  explicit 
./utilities/clifford.hpp:78:8: warning: function 'Clifford::MeasZ' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  bool MeasZ(const uint64_t qubit, const uint64_t rand);
       ^
                                                  randint
./utilities/clifford.hpp:198:16: note: the definition seen here
bool Clifford::MeasZ(const uint64_t qubit, const uint64_t randint) {
               ^
./utilities/clifford.hpp:78:8: note: differing parameters are named here: ('rand'), in definition: ('randint')
  bool MeasZ(const uint64_t qubit, const uint64_t rand);
       ^
./utilities/clifford.hpp:79:8: warning: function 'Clifford::MeasX' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  bool MeasX(const uint64_t qubit, const uint64_t rand);
       ^
                                                  randint
./utilities/clifford.hpp:236:16: note: the definition seen here
bool Clifford::MeasX(const uint64_t qubit, const uint64_t randint) {
               ^
./utilities/clifford.hpp:79:8: note: differing parameters are named here: ('rand'), in definition: ('randint')
  bool MeasX(const uint64_t qubit, const uint64_t rand);
       ^
./utilities/clifford.hpp:80:8: warning: function 'Clifford::MeasY' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  bool MeasY(const uint64_t qubit, const uint64_t rand);
       ^
                                                  randint
./utilities/clifford.hpp:243:16: note: the definition seen here
bool Clifford::MeasY(const uint64_t qubit, const uint64_t randint) {
               ^
./utilities/clifford.hpp:80:8: note: differing parameters are named here: ('rand'), in definition: ('randint')
  bool MeasY(const uint64_t qubit, const uint64_t rand);
       ^
./utilities/clifford.hpp:81:8: warning: function 'Clifford::PrepZ' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void PrepZ(const uint64_t qubit, const uint64_t rand);
       ^
                                                  randint
./utilities/clifford.hpp:251:16: note: the definition seen here
void Clifford::PrepZ(const uint64_t qubit, const uint64_t randint) {
               ^
./utilities/clifford.hpp:81:8: note: differing parameters are named here: ('rand'), in definition: ('randint')
  void PrepZ(const uint64_t qubit, const uint64_t rand);
       ^
./utilities/clifford.hpp:82:8: warning: function 'Clifford::PrepX' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void PrepX(const uint64_t qubit, const uint64_t rand);
       ^
                                                  randint
./utilities/clifford.hpp:257:16: note: the definition seen here
void Clifford::PrepX(const uint64_t qubit, const uint64_t randint) {
               ^
./utilities/clifford.hpp:82:8: note: differing parameters are named here: ('rand'), in definition: ('randint')
  void PrepX(const uint64_t qubit, const uint64_t rand);
       ^
./utilities/clifford.hpp:83:8: warning: function 'Clifford::PrepY' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void PrepY(const uint64_t qubit, const uint64_t rand);
       ^
                                                  randint
./utilities/clifford.hpp:265:16: note: the definition seen here
void Clifford::PrepY(const uint64_t qubit, const uint64_t randint) {
               ^
./utilities/clifford.hpp:83:8: note: differing parameters are named here: ('rand'), in definition: ('randint')
  void PrepY(const uint64_t qubit, const uint64_t rand);
       ^
./utilities/clifford.hpp:108:11: warning: function 'Clifford' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
Clifford::Clifford(uint64_t nq) : nqubits(nq) {
          ^
inline 
./utilities/clifford.hpp:113:18: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    P.X.setValue(1, i);
                 ^
                 true
./utilities/clifford.hpp:114:15: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    P.phase = 0;
              ^
              false
./utilities/clifford.hpp:120:18: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    P.Z.setValue(1, i);
                 ^
                 true
./utilities/clifford.hpp:121:15: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    P.phase = 0;
              ^
              false
./utilities/clifford.hpp:130:15: warning: function 'g' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
int Clifford::g(bool x1, bool z1, bool x2, bool z2) {
              ^
inline 
./utilities/clifford.hpp:132:8: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      (x2 * z1 * (1 + 2 * z2 + 2 * x1) - x1 * z2 * (1 + 2 * z1 + 2 * x2)) % 4;
       ^
       static_cast<int>( )
./utilities/clifford.hpp:132:13: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      (x2 * z1 * (1 + 2 * z2 + 2 * x1) - x1 * z2 * (1 + 2 * z1 + 2 * x2)) % 4;
            ^
            static_cast<int>( )
./utilities/clifford.hpp:132:27: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      (x2 * z1 * (1 + 2 * z2 + 2 * x1) - x1 * z2 * (1 + 2 * z1 + 2 * x2)) % 4;
                          ^
                          static_cast<int>( )
./utilities/clifford.hpp:132:36: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      (x2 * z1 * (1 + 2 * z2 + 2 * x1) - x1 * z2 * (1 + 2 * z1 + 2 * x2)) % 4;
                                   ^
                                   static_cast<int>( )
./utilities/clifford.hpp:132:42: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      (x2 * z1 * (1 + 2 * z2 + 2 * x1) - x1 * z2 * (1 + 2 * z1 + 2 * x2)) % 4;
                                         ^
                                         static_cast<int>( )
./utilities/clifford.hpp:132:47: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      (x2 * z1 * (1 + 2 * z2 + 2 * x1) - x1 * z2 * (1 + 2 * z1 + 2 * x2)) % 4;
                                              ^
                                              static_cast<int>( )
./utilities/clifford.hpp:132:61: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      (x2 * z1 * (1 + 2 * z2 + 2 * x1) - x1 * z2 * (1 + 2 * z1 + 2 * x2)) % 4;
                                                            ^
                                                            static_cast<int>( )
./utilities/clifford.hpp:132:70: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
      (x2 * z1 * (1 + 2 * z2 + 2 * x1) - x1 * z2 * (1 + 2 * z1 + 2 * x2)) % 4;
                                                                     ^
                                                                     static_cast<int>( )
./utilities/clifford.hpp:133:17: warning: statement should be inside braces [readability-braces-around-statements]
  if (phase < 0)
                ^
./utilities/clifford.hpp:138:16: warning: function 'rowsum' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::rowsum(uint64_t h, uint64_t i) {
               ^
inline 
./utilities/clifford.hpp:139:18: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
  int newr = 2 * table[h].phase + 2 * table[i].phase;
                 ^
                 static_cast<int>( )
./utilities/clifford.hpp:139:39: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
  int newr = 2 * table[h].phase + 2 * table[i].phase;
                                      ^
                                      static_cast<int>( )
./utilities/clifford.hpp:140:41: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint64_t q = 0; q < nqubits; q++)
                                        ^
./utilities/clifford.hpp:143:3: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
  assert(((newr == 0) || (newr == 2)));
  ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./utilities/clifford.hpp:150:16: warning: function 'CX' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::CX(const uint64_t qcon, const uint64_t qtar) {
               ^
inline 
./utilities/clifford.hpp:151:45: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint64_t i = 0; i < 2 * nqubits; i++)
                                            ^
./utilities/clifford.hpp:152:23: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].phase ^= table[i].X[qcon] && table[i].Z[qtar] &&
                      ^
./utilities/clifford.hpp:153:23: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
                      (table[i].X[qtar] ^ table[i].Z[qcon] ^ 1);
                      ^
                      (                                         != 0)
./utilities/clifford.hpp:153:24: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
                      (table[i].X[qtar] ^ table[i].Z[qcon] ^ 1);
                       ^
                       static_cast<int>( )
./utilities/clifford.hpp:153:43: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
                      (table[i].X[qtar] ^ table[i].Z[qcon] ^ 1);
                                          ^
                                          static_cast<int>( )
./utilities/clifford.hpp:155:25: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    table[i].X.setValue(table[i].X[qtar] ^ table[i].X[qcon], qtar);
                        ^
                        (                                  ) != 0
./utilities/clifford.hpp:155:25: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].X.setValue(table[i].X[qtar] ^ table[i].X[qcon], qtar);
                        ^
                        static_cast<int>( )
./utilities/clifford.hpp:155:44: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].X.setValue(table[i].X[qtar] ^ table[i].X[qcon], qtar);
                                           ^
                                           static_cast<int>( )
./utilities/clifford.hpp:156:25: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    table[i].Z.setValue(table[i].Z[qtar] ^ table[i].Z[qcon], qcon);
                        ^
                        (                                  ) != 0
./utilities/clifford.hpp:156:25: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].Z.setValue(table[i].Z[qtar] ^ table[i].Z[qcon], qcon);
                        ^
                        static_cast<int>( )
./utilities/clifford.hpp:156:44: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].Z.setValue(table[i].Z[qtar] ^ table[i].Z[qcon], qcon);
                                           ^
                                           static_cast<int>( )
./utilities/clifford.hpp:160:16: warning: function 'CZ' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::CZ(const uint64_t q1, const uint64_t q2) {
               ^
inline 
./utilities/clifford.hpp:166:16: warning: function 'H' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::H(const uint64_t qubit) {
               ^
inline 
./utilities/clifford.hpp:168:23: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].phase ^= (table[i].X[qubit] && table[i].Z[qubit]);
                      ^
                      static_cast<int>
./utilities/clifford.hpp:176:16: warning: function 'S' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::S(const uint64_t qubit) {
               ^
inline 
./utilities/clifford.hpp:178:23: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].phase ^= (table[i].X[qubit] && table[i].Z[qubit]);
                      ^
                      static_cast<int>
./utilities/clifford.hpp:179:25: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    table[i].Z.setValue(table[i].Z[qubit] ^ table[i].X[qubit], qubit);
                        ^
                        (                                    ) != 0
./utilities/clifford.hpp:179:25: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].Z.setValue(table[i].Z[qubit] ^ table[i].X[qubit], qubit);
                        ^
                        static_cast<int>()
./utilities/clifford.hpp:179:45: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].Z.setValue(table[i].Z[qubit] ^ table[i].X[qubit], qubit);
                                            ^
                                            static_cast<int>()
./utilities/clifford.hpp:183:16: warning: function 'X' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::X(const uint64_t qubit) {
               ^
inline 
./utilities/clifford.hpp:184:45: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint64_t i = 0; i < 2 * nqubits; i++)
                                            ^
./utilities/clifford.hpp:185:23: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].phase ^= table[i].Z[qubit];
                      ^
                      static_cast<int>()
./utilities/clifford.hpp:188:16: warning: function 'Y' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::Y(const uint64_t qubit) {
               ^
inline 
./utilities/clifford.hpp:189:45: warning: statement should be inside braces [readability-braces-around-statements]
  for (uint64_t i = 0; i < 2 * nqubits; i++)
                                            ^
./utilities/clifford.hpp:190:24: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].phase ^= (table[i].Z[qubit] ^ table[i].X[qubit]);
                       ^
                       static_cast<int>()
./utilities/clifford.hpp:190:44: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].phase ^= (table[i].Z[qubit] ^ table[i].X[qubit]);
                                           ^
                                           static_cast<int>()
./utilities/clifford.hpp:193:16: warning: function 'Z' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::Z(const uint64_t qubit) {
               ^
inline 
./utilities/clifford.hpp:194:45: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint64_t i = 0; i < 2 * nqubits; i++)
                                            ^
./utilities/clifford.hpp:195:23: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    table[i].phase ^= table[i].X[qubit];
                      ^
                      static_cast<int>()
./utilities/clifford.hpp:198:16: warning: function 'MeasZ' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool Clifford::MeasZ(const uint64_t qubit, const uint64_t randint) {
               ^
inline 
./utilities/clifford.hpp:201:20: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
  bool is_random = 0;
                   ^
                   false
./utilities/clifford.hpp:204:42: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (p = nqubits; p < 2 * nqubits; p++)
                                         ^
./utilities/clifford.hpp:206:19: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
      is_random = 1;
                  ^
                  true
./utilities/clifford.hpp:211:47: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (uint64_t i = 0; i < 2 * nqubits; i++)
                                              ^
./utilities/clifford.hpp:213:67: warning: statement should be inside braces [google-readability-braces-around-statements]
      if ((table[i].X[qubit]) && (i != p) && (i != (p - nqubits)))
                                                                  ^
./utilities/clifford.hpp:220:25: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    table[p].Z.setValue(1, qubit);
                        ^
                        true
./utilities/clifford.hpp:227:32: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    table[2 * nqubits].phase = 0;
                               ^
                               false
./utilities/clifford.hpp:228:43: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (uint64_t i = 0; i < nqubits; i++)
                                          ^
./utilities/clifford.hpp:229:29: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (table[i].X[qubit])
                            ^
./utilities/clifford.hpp:236:16: warning: function 'MeasX' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool Clifford::MeasX(const uint64_t qubit, const uint64_t randint) {
               ^
inline 
./utilities/clifford.hpp:243:16: warning: function 'MeasY' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool Clifford::MeasY(const uint64_t qubit, const uint64_t randint) {
               ^
inline 
./utilities/clifford.hpp:251:16: warning: function 'PrepZ' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::PrepZ(const uint64_t qubit, const uint64_t randint) {
               ^
inline 
./utilities/clifford.hpp:253:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (b)
        ^
./utilities/clifford.hpp:257:16: warning: function 'PrepX' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::PrepX(const uint64_t qubit, const uint64_t randint) {
               ^
inline 
./utilities/clifford.hpp:261:9: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (b)
        ^
./utilities/clifford.hpp:265:16: warning: function 'PrepY' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::PrepY(const uint64_t qubit, const uint64_t randint) {
               ^
inline 
./utilities/clifford.hpp:270:16: warning: function 'Reset' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void Clifford::Reset() {
               ^
inline 
./utilities/clifford.hpp:276:22: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    table[q].phase = 0;
                     ^
                     false
./utilities/clifford.hpp:277:25: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    table[q].X.setValue(1, q);
                        ^
                        true
./utilities/clifford.hpp:281:32: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    table[q + nqubits].phase = 0;
                               ^
                               false
./utilities/clifford.hpp:282:35: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
    table[q + nqubits].Z.setValue(1, q);
                                  ^
                                  true
./utilities/clifford.hpp:288:30: warning: implicit cast 'int' -> bool [readability-implicit-bool-cast]
  table[2 * nqubits].phase = 0;
                             ^
                             false
./utilities/matrix.hpp:198:29: warning: function 'operator*' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  friend std::vector<float> operator*(const matrix<float> &A,
                            ^
./utilities/matrix.hpp:1040:27: note: the definition seen here
inline std::vector<float> operator*(const matrix<float> &A,
                          ^
./utilities/matrix.hpp:198:29: note: differing parameters are named here: ('v'), in definition: ('x')
  friend std::vector<float> operator*(const matrix<float> &A,
                            ^
./utilities/matrix.hpp:201:3: warning: function 'operator*' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  operator*(const matrix<std::complex<float>> &A,
  ^
./utilities/matrix.hpp:1063:1: note: the definition seen here
operator*(const matrix<std::complex<float>> &A,
^
./utilities/matrix.hpp:201:3: note: differing parameters are named here: ('v'), in definition: ('x')
  operator*(const matrix<std::complex<float>> &A,
  ^
./utilities/matrix.hpp:204:30: warning: function 'operator*' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  friend std::vector<double> operator*(const matrix<double> &A,
                             ^
./utilities/matrix.hpp:1051:28: note: the definition seen here
inline std::vector<double> operator*(const matrix<double> &A,
                           ^
./utilities/matrix.hpp:204:30: note: differing parameters are named here: ('v'), in definition: ('x')
  friend std::vector<double> operator*(const matrix<double> &A,
                             ^
./utilities/matrix.hpp:207:3: warning: function 'operator*' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  operator*(const matrix<std::complex<double>> &A,
  ^
./utilities/matrix.hpp:1075:1: note: the definition seen here
operator*(const matrix<std::complex<double>> &A,
^
./utilities/matrix.hpp:207:3: note: differing parameters are named here: ('v'), in definition: ('x')
  operator*(const matrix<std::complex<double>> &A,
  ^
./utilities/matrix.hpp:214:3: warning: function 'matrix::matrix<T>' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  matrix(size_t size); // Makes a square matrix and rows = sqrt(size) columns =
  ^
                dim2
./utilities/matrix.hpp:525:19: note: the definition seen here
inline matrix<T>::matrix(size_t dim2)
                  ^
./utilities/matrix.hpp:214:3: note: differing parameters are named here: ('size'), in definition: ('dim2')
  matrix(size_t size); // Makes a square matrix and rows = sqrt(size) columns =
  ^
./utilities/matrix.hpp:214:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  matrix(size_t size); // Makes a square matrix and rows = sqrt(size) columns =
  ^
  explicit 
./utilities/matrix.hpp:216:3: warning: function 'matrix::matrix<T>' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  matrix(const matrix<T> &m);
  ^
                          rhs
./utilities/matrix.hpp:557:19: note: the definition seen here
inline matrix<T>::matrix(const matrix<T> &rhs)
                  ^
./utilities/matrix.hpp:216:3: note: differing parameters are named here: ('m'), in definition: ('rhs')
  matrix(const matrix<T> &m);
  ^
./utilities/matrix.hpp:217:3: warning: function 'matrix::matrix<T>' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  matrix(const matrix<T> &m, const char uplo);
  ^
                          rhs
./utilities/matrix.hpp:566:19: note: the definition seen here
inline matrix<T>::matrix(const matrix<T> &rhs, const char uplo)
                  ^
./utilities/matrix.hpp:217:3: note: differing parameters are named here: ('m'), in definition: ('rhs')
  matrix(const matrix<T> &m, const char uplo);
  ^
./utilities/matrix.hpp:228:14: warning: function 'matrix::operator=' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  matrix<T> &operator=(const matrix<T> &m);
             ^
                                        rhs
./utilities/matrix.hpp:631:30: note: the definition seen here
inline matrix<T> &matrix<T>::operator=(const matrix<T> &rhs) {
                             ^
./utilities/matrix.hpp:228:14: note: differing parameters are named here: ('m'), in definition: ('rhs')
  matrix<T> &operator=(const matrix<T> &m);
             ^
./utilities/matrix.hpp:230:14: warning: function 'matrix::operator=' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  matrix<T> &operator=(const matrix<S> &m); // Still would like to have real
             ^
                                        rhs
./utilities/matrix.hpp:657:30: note: the definition seen here
inline matrix<T> &matrix<T>::operator=(const matrix<S> &rhs) {
                             ^
./utilities/matrix.hpp:230:14: note: differing parameters are named here: ('m'), in definition: ('rhs')
  matrix<T> &operator=(const matrix<S> &m); // Still would like to have real
             ^
./utilities/matrix.hpp:235:6: warning: function 'matrix::operator[]' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  T &operator[](size_t element);
     ^
                       p
./utilities/matrix.hpp:680:41: note: the definition seen here
template <class T> inline T &matrix<T>::operator[](size_t p) {
                                        ^
./utilities/matrix.hpp:235:6: note: differing parameters are named here: ('element'), in definition: ('p')
  T &operator[](size_t element);
     ^
./utilities/matrix.hpp:236:5: warning: function 'matrix::operator[]' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  T operator[](size_t element) const;
    ^
                      p
./utilities/matrix.hpp:693:40: note: the definition seen here
template <class T> inline T matrix<T>::operator[](size_t p) const {
                                       ^
./utilities/matrix.hpp:236:5: note: differing parameters are named here: ('element'), in definition: ('p')
  T operator[](size_t element) const;
    ^
./utilities/matrix.hpp:238:6: warning: function 'matrix::operator()' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  T &operator()(size_t row, size_t col);
     ^
                       i           j
./utilities/matrix.hpp:706:41: note: the definition seen here
template <class T> inline T &matrix<T>::operator()(size_t i, size_t j) {
                                        ^
./utilities/matrix.hpp:238:6: note: differing parameters are named here: ('row', 'col'), in definition: ('i', 'j')
  T &operator()(size_t row, size_t col);
     ^
./utilities/matrix.hpp:239:5: warning: function 'matrix::operator()' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  T operator()(size_t row, size_t col) const;
    ^
                      i           j
./utilities/matrix.hpp:719:40: note: the definition seen here
template <class T> inline T matrix<T>::operator()(size_t i, size_t j) const {
                                       ^
./utilities/matrix.hpp:239:5: note: differing parameters are named here: ('row', 'col'), in definition: ('i', 'j')
  T operator()(size_t row, size_t col) const;
    ^
./utilities/matrix.hpp:254:8: warning: function 'matrix::resize' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void resize(size_t row, size_t col); // sets the size of the underlying vector
       ^
                     rows        cols
./utilities/matrix.hpp:608:43: note: the definition seen here
template <class T> inline void matrix<T>::resize(size_t rows, size_t cols) {
                                          ^
./utilities/matrix.hpp:254:8: note: differing parameters are named here: ('row', 'col'), in definition: ('rows', 'cols')
  void resize(size_t row, size_t col); // sets the size of the underlying vector
       ^
./utilities/matrix.hpp:295:57: warning: all parameters should be named in a function [readability-named-parameter]
template <class T> matrix<T> TraceOutA(const matrix<T> &, size_t);
                                                        ^
                                                         /*rho*/ /*dimA*/
./utilities/matrix.hpp:296:57: warning: all parameters should be named in a function [readability-named-parameter]
template <class T> matrix<T> TraceOutB(const matrix<T> &, size_t);
                                                        ^
                                                         /*rho*/ /*dimB*/
./utilities/matrix.hpp:299:2: warning: namespace 'MOs' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace MOs
./utilities/matrix.hpp:278:11: note: namespace 'MOs' starts here
namespace MOs {
          ^
./utilities/matrix.hpp:303:43: warning: statement should be inside braces [readability-braces-around-statements]
  for (size_t i = 0; i < A.GetRows(); i++)
                                          ^
./utilities/matrix.hpp:304:48: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t j = 0; j < A.GetColumns(); j++)
                                               ^
./utilities/matrix.hpp:312:29: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (dim != I.GetColumns())
                            ^
./utilities/matrix.hpp:315:35: warning: statement should be inside braces [readability-braces-around-statements]
  for (size_t i = 0; i < dim; i++)
                                  ^
./utilities/matrix.hpp:316:37: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t j = 0; j < dim; j++)
                                    ^
./utilities/matrix.hpp:411:20: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (rows != cols)
                   ^
./utilities/matrix.hpp:516:10: warning: use nullptr [modernize-use-nullptr]
  mat_ = 0;
         ^
         nullptr
./utilities/matrix.hpp:531:18: warning: statement should be inside braces [readability-braces-around-statements]
  if (size_ == 0)
                 ^
./utilities/matrix.hpp:533:23: warning: statement should be inside braces [readability-braces-around-statements]
  else if (size_ == 1)
                      ^
./utilities/matrix.hpp:540:9: warning: statement should be inside braces [readability-braces-around-statements]
  } else
        ^
./utilities/matrix.hpp:542:34: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (size_ == rows_ * rows_)
                                 ^
./utilities/matrix.hpp:562:5: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    mat_[p] = rhs.mat_[p];
    ^
./utilities/matrix.hpp:562:15: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    mat_[p] = rhs.mat_[p];
              ^
./utilities/matrix.hpp:572:39: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t i = 0; i < rows_; i++)
                                      ^
./utilities/matrix.hpp:573:41: warning: statement should be inside braces [google-readability-braces-around-statements]
      for (size_t j = i; j < cols_; j++)
                                        ^
./utilities/matrix.hpp:576:39: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (size_t i = 0; i < rows_; i++)
                                      ^
./utilities/matrix.hpp:577:38: warning: statement should be inside braces [readability-braces-around-statements]
      for (size_t j = 0; j <= i; j++)
                                     ^
./utilities/matrix.hpp:589:19: warning: statement should be inside braces [readability-braces-around-statements]
    if (mat_ != 0)
                  ^
./utilities/matrix.hpp:601:17: warning: implicit cast 'size_t' -> bool [readability-implicit-bool-cast]
  if (!mat_ || !size_)
                ^
               (      == 0u)
./utilities/matrix.hpp:601:23: warning: statement should be inside braces [readability-braces-around-statements]
  if (!mat_ || !size_)
                      ^
./utilities/matrix.hpp:609:38: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (rows_ == rows && cols_ == cols)
                                     ^
./utilities/matrix.hpp:611:3: warning: use auto when initializing with new to avoid duplicating the type name [modernize-use-auto]
  T *tempmat = new T[size_ = rows * cols];
  ^
  auto 
./utilities/matrix.hpp:613:36: warning: statement should be inside braces [readability-braces-around-statements]
  for (size_t i = 0; i < rows; i++)
                                   ^
./utilities/matrix.hpp:614:38: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (size_t j = 0; j < cols; j++)
                                     ^
./utilities/matrix.hpp:615:34: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (i < rows_ && j < cols_)
                                 ^
./utilities/matrix.hpp:616:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        tempmat[j * rows + i] = mat_[j * rows_ + i];
        ^
./utilities/matrix.hpp:616:33: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        tempmat[j * rows + i] = mat_[j * rows_ + i];
                                ^
./utilities/matrix.hpp:617:11: warning: statement should be inside braces [readability-braces-around-statements]
      else
          ^
./utilities/matrix.hpp:618:9: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
        tempmat[j * rows + i] = 0.0;
        ^
./utilities/matrix.hpp:627:15: warning: use nullptr [modernize-use-nullptr]
  if (mat_ != 0)
              ^
              nullptr
./utilities/matrix.hpp:627:17: warning: statement should be inside braces [readability-braces-around-statements]
  if (mat_ != 0)
                ^
./utilities/matrix.hpp:640:17: warning: use nullptr [modernize-use-nullptr]
    if (mat_ != 0)
                ^
                nullptr
./utilities/matrix.hpp:640:19: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (mat_ != 0)
                  ^
./utilities/matrix.hpp:651:5: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    mat_[p] = T(rhs.mat_[p]);
    ^
./utilities/matrix.hpp:651:17: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    mat_[p] = T(rhs.mat_[p]);
                ^
./utilities/matrix.hpp:666:17: warning: use nullptr [modernize-use-nullptr]
    if (mat_ != 0)
                ^
                nullptr
./utilities/matrix.hpp:666:19: warning: statement should be inside braces [readability-braces-around-statements]
    if (mat_ != 0)
                  ^
./utilities/matrix.hpp:676:5: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    mat_[p] = T(rhs[p]);
    ^
./utilities/matrix.hpp:691:10: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
  return mat_[p];
         ^
./utilities/matrix.hpp:704:10: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
  return mat_[p];
         ^
./utilities/matrix.hpp:717:10: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
  return mat_[j * rows_ + i];
         ^
./utilities/matrix.hpp:729:10: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
  return mat_[j * rows_ + i];
         ^
./utilities/matrix.hpp:768:5: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    temp.mat_[p] = mat_[p] + A.mat_[p];
    ^
./utilities/matrix.hpp:768:20: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    temp.mat_[p] = mat_[p] + A.mat_[p];
                   ^
./utilities/matrix.hpp:768:30: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    temp.mat_[p] = mat_[p] + A.mat_[p];
                             ^
./utilities/matrix.hpp:784:20: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    temp.mat_[p] = mat_[p] - A.mat_[p];
                   ^
./utilities/matrix.hpp:802:20: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    temp.mat_[p] = mat_[p] + A.mat_[p];
                   ^
./utilities/matrix.hpp:819:20: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    temp.mat_[p] = mat_[p] - A.mat_[p];
                   ^
./utilities/matrix.hpp:835:5: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    mat_[p] += A.mat_[p];
    ^
./utilities/matrix.hpp:835:16: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    mat_[p] += A.mat_[p];
               ^
./utilities/matrix.hpp:851:5: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
    mat_[p] -= A.mat_[p];
    ^
./utilities/misc.hpp:141:28: warning: function 'renormalize' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
template <typename T> void renormalize(std::vector<T> &v);
                           ^
                                                       vec
./utilities/misc.hpp:562:28: note: the definition seen here
template <typename T> void renormalize(std::vector<T> &vec) {
                           ^
./utilities/misc.hpp:141:28: note: differing parameters are named here: ('v'), in definition: ('vec')
template <typename T> void renormalize(std::vector<T> &v);
                           ^
./utilities/misc.hpp:232:13: warning: function 'int2string' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
std::string int2string(uint_t n, uint_t base, uint_t length);
            ^
                                                     minlen
./utilities/misc.hpp:702:13: note: the definition seen here
std::string int2string(uint_t n, uint_t base, uint_t minlen) {
            ^
./utilities/misc.hpp:232:13: note: differing parameters are named here: ('length'), in definition: ('minlen')
std::string int2string(uint_t n, uint_t base, uint_t length);
            ^
./utilities/misc.hpp:327:6: warning: function 'to_lowercase' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void to_lowercase(std::string &str) {
     ^
inline 
./utilities/misc.hpp:331:13: warning: function 'read_file' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::string read_file(std::string infile) {
            ^
inline 
./utilities/misc.hpp:345:6: warning: function 'write_file' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void write_file(std::string outfile, std::string contents) {
     ^
inline 
./utilities/misc.hpp:357:13: warning: function 'read_stream' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::string read_stream(std::istream &input) {
            ^
inline 
./utilities/misc.hpp:360:53: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (std::string line; std::getline(input, line);)
                                                    ^
./utilities/misc.hpp:368:26: warning: function 'read_stream' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::vector<std::string> read_stream(std::istream &input,
                         ^
inline 
./utilities/misc.hpp:380:11: warning: statement should be inside braces [google-readability-braces-around-statements]
    } else
          ^
./utilities/misc.hpp:394:9: warning: function 'operator+=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cket_t &operator+=(cket_t &m1, const cket_t &m2) {
        ^
inline 
./utilities/misc.hpp:395:27: warning: statement should be inside braces [readability-braces-around-statements]
  for (const auto &p : m2)
                          ^
./utilities/misc.hpp:400:8: warning: function 'operator+' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cket_t operator+(const cket_t &m1, const cket_t &m2) {
       ^
inline 
./utilities/misc.hpp:406:9: warning: function 'operator*=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cket_t &operator*=(cket_t &m1, const complex_t z) {
        ^
inline 
./utilities/misc.hpp:407:27: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (const auto &p : m1)
                          ^
./utilities/misc.hpp:412:8: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cket_t operator*(const cket_t &m1, const complex_t z) {
       ^
inline 
./utilities/misc.hpp:418:8: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cket_t operator*(const complex_t z, const cket_t &m1) { return m1 * z; }
       ^
inline 
./utilities/misc.hpp:420:9: warning: function 'operator+=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rket_t &operator+=(rket_t &m1, const rket_t &m2) {
        ^
inline 
./utilities/misc.hpp:421:27: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (const auto &p : m2)
                          ^
./utilities/misc.hpp:425:8: warning: function 'operator+' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rket_t operator+(const rket_t &m1, const rket_t &m2) {
       ^
inline 
./utilities/misc.hpp:430:9: warning: function 'operator*=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rket_t &operator*=(rket_t &m1, const double z) {
        ^
inline 
./utilities/misc.hpp:431:27: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (const auto &p : m1)
                          ^
./utilities/misc.hpp:436:8: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rket_t operator*(const rket_t &m1, const double z) {
       ^
inline 
./utilities/misc.hpp:442:8: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rket_t operator*(const double z, const rket_t &m1) { return m1 * z; }
       ^
inline 
./utilities/misc.hpp:448:12: warning: function 'operator+=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t &operator+=(rvector_t &v1, const rvector_t &v2) {
           ^
inline 
./utilities/misc.hpp:449:18: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (v1.empty()) // allow adding to empty vector
                 ^
./utilities/misc.hpp:452:43: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (size_t j = 0; j < v1.size(); j++)
                                          ^
./utilities/misc.hpp:455:5: warning: don't use else after return [readability-else-after-return]
  } else {
    ^
./utilities/misc.hpp:460:12: warning: function 'operator+=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t &operator+=(cvector_t &v1, const cvector_t &v2) {
           ^
inline 
./utilities/misc.hpp:461:18: warning: statement should be inside braces [readability-braces-around-statements]
  if (v1.empty()) // allow adding to empty vector
                 ^
./utilities/misc.hpp:464:43: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t j = 0; j < v1.size(); j++)
                                          ^
./utilities/misc.hpp:467:5: warning: don't use else after return [readability-else-after-return]
  } else {
    ^
./utilities/misc.hpp:472:12: warning: function 'operator-=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t &operator-=(rvector_t &v1, const rvector_t &v2) {
           ^
inline 
./utilities/misc.hpp:473:18: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (v1.empty()) // allow adding to empty vector
                 ^
./utilities/misc.hpp:476:43: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t j = 0; j < v1.size(); j++)
                                          ^
./utilities/misc.hpp:479:5: warning: don't use else after return [readability-else-after-return]
  } else {
    ^
./utilities/misc.hpp:484:12: warning: function 'operator-=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t &operator-=(cvector_t &v1, const cvector_t &v2) {
           ^
inline 
./utilities/misc.hpp:485:18: warning: statement should be inside braces [readability-braces-around-statements]
  if (v1.empty()) // allow adding to empty vector
                 ^
./utilities/misc.hpp:488:43: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t j = 0; j < v1.size(); j++)
                                          ^
./utilities/misc.hpp:491:5: warning: don't use else after return [readability-else-after-return]
  } else {
    ^
./utilities/misc.hpp:496:12: warning: function 'operator*=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t &operator*=(rvector_t &v1, const double a) {
           ^
inline 
./utilities/misc.hpp:497:3: warning: use range-based for loop instead [modernize-loop-convert]
  for (size_t j = 0; j < v1.size(); j++)
  ^
./utilities/misc.hpp:497:41: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (size_t j = 0; j < v1.size(); j++)
                                        ^
./utilities/misc.hpp:502:12: warning: function 'operator*=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t &operator*=(cvector_t &v1, const complex_t z) {
           ^
inline 
./utilities/misc.hpp:503:3: warning: use range-based for loop instead [modernize-loop-convert]
  for (size_t j = 0; j < v1.size(); j++)
  ^
./utilities/misc.hpp:503:41: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (size_t j = 0; j < v1.size(); j++)
                                        ^
./utilities/misc.hpp:508:11: warning: function 'operator+' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t operator+(const rvector_t &v1, const rvector_t &v2) {
          ^
inline 
./utilities/misc.hpp:514:11: warning: function 'operator+' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t operator+(const cvector_t &v1, const cvector_t &v2) {
          ^
inline 
./utilities/misc.hpp:520:11: warning: function 'operator-' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t operator-(const rvector_t &v1, const rvector_t &v2) {
          ^
inline 
./utilities/misc.hpp:526:11: warning: function 'operator-' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t operator-(const cvector_t &v1, const cvector_t &v2) {
          ^
inline 
./utilities/misc.hpp:532:11: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t operator*(const rvector_t &v1, const double a) {
          ^
inline 
./utilities/misc.hpp:538:11: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t operator*(const cvector_t &v1, const complex_t z) {
          ^
inline 
./utilities/misc.hpp:544:11: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t operator*(const double a, const rvector_t &v1) { return v1 * a; }
          ^
inline 
./utilities/misc.hpp:546:11: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t operator*(const complex_t z, const cvector_t &v1) { return v1 * z; }
          ^
inline 
./utilities/misc.hpp:556:10: warning: consider replacing 'unsigned long' with 'uint64' [google-runtime-int]
    for (unsigned long j = 0; j != v1.size(); j++)
         ^
./utilities/misc.hpp:556:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (unsigned long j = 0; j != v1.size(); j++)
                                                  ^
./utilities/misc.hpp:564:28: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (const auto &e : vec)
                           ^
./utilities/misc.hpp:566:22: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (auto &e : vec)
                     ^
./utilities/misc.hpp:578:43: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint_t j = 0; j != vec.size(); j++)
                                          ^
./utilities/misc.hpp:586:43: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint_t j = 0; j != vec.size(); j++)
                                          ^
./utilities/misc.hpp:596:34: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint_t i = 0; i < d1; i++)
                                 ^
./utilities/misc.hpp:608:29: warning: statement should be inside braces [readability-braces-around-statements]
  for (const auto &p1 : ket)
                            ^
./utilities/misc.hpp:623:9: warning: function 'chop' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double &chop(double &val, double epsilon) {
        ^
inline 
./utilities/misc.hpp:624:31: warning: statement should be inside braces [readability-braces-around-statements]
  if (std::abs(val) < epsilon)
                              ^
./utilities/misc.hpp:629:12: warning: function 'chop' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t &chop(complex_t &val, double epsilon) {
           ^
inline 
./utilities/misc.hpp:630:38: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (std::abs(val.real()) < epsilon)
                                     ^
./utilities/misc.hpp:632:38: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (std::abs(val.imag()) < epsilon)
                                     ^
./utilities/misc.hpp:639:20: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (epsilon > 0.)
                   ^
./utilities/misc.hpp:640:24: warning: statement should be inside braces [readability-braces-around-statements]
    for (auto &v : vec)
                       ^
./utilities/misc.hpp:647:20: warning: statement should be inside braces [readability-braces-around-statements]
  if (epsilon > 0.)
                   ^
./utilities/misc.hpp:650:40: warning: statement should be inside braces [google-readability-braces-around-statements]
      if (std::abs(p.second) < epsilon)
                                       ^
./utilities/misc.hpp:657:20: warning: statement should be inside braces [readability-braces-around-statements]
  if (epsilon > 0.)
                   ^
./utilities/misc.hpp:658:57: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (uint_t col = 0; col != mat.GetColumns(); col++)
                                                        ^
./utilities/misc.hpp:659:56: warning: statement should be inside braces [readability-braces-around-statements]
      for (uint_t row = 0; row != mat.GetRows(); row++)
                                                       ^
./utilities/misc.hpp:668:11: warning: function 'devectorize' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cmatrix_t devectorize(const cvector_t &vec) {
          ^
inline 
./utilities/misc.hpp:675:42: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint_t col = 0; col != dim; col++)
                                         ^
./utilities/misc.hpp:676:44: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (uint_t row = 0; row != dim; row++)
                                           ^
./utilities/misc.hpp:681:11: warning: function 'vectorize' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cvector_t vectorize(const cmatrix_t &mat) {
          ^
inline 
./utilities/misc.hpp:685:43: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint_t col = 0; col != ncol; col++)
                                          ^
./utilities/misc.hpp:686:45: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (uint_t row = 0; row != nrow; row++)
                                            ^
./utilities/misc.hpp:695:13: warning: function 'int2string' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::string int2string(uint_t n, uint_t base) {
            ^
inline 
./utilities/misc.hpp:696:16: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (n < base)
               ^
./utilities/misc.hpp:698:3: warning: don't use else after return [readability-else-after-return]
  else
  ^
./utilities/misc.hpp:698:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/misc.hpp:702:13: warning: function 'int2string' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::string int2string(uint_t n, uint_t base, uint_t minlen) {
            ^
inline 
./utilities/misc.hpp:705:18: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (l < minlen)
                 ^
./utilities/misc.hpp:714:21: warning: function 'int2reg' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::vector<uint_t> int2reg(uint_t n, uint_t base) {
                    ^
inline 
./utilities/misc.hpp:724:21: warning: function 'int2reg' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::vector<uint_t> int2reg(uint_t n, uint_t base, uint_t minlen) {
                    ^
inline 
./utilities/misc.hpp:726:27: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (ret.size() < minlen) // pad vector with zeros
                          ^
./utilities/misc.hpp:735:21: warning: function 'hex2reg' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::vector<uint_t> hex2reg(std::string str) {
                    ^
inline 
./utilities/misc.hpp:743:7: warning: consider replacing 'unsigned long' with 'uint64' [google-runtime-int]
      unsigned long hex = stoul(str.substr(str.size() - 8), 0, 16);
      ^
./utilities/misc.hpp:743:61: warning: use nullptr [modernize-use-nullptr]
      unsigned long hex = stoul(str.substr(str.size() - 8), 0, 16);
                                                            ^
                                                            nullptr
./utilities/misc.hpp:749:52: warning: use nullptr [modernize-use-nullptr]
      std::vector<uint_t> tmp = int2reg(stoul(str, 0, 16), 2, 0);
                                                   ^
                                                   nullptr
./utilities/misc.hpp:753:5: warning: don't use else after return [readability-else-after-return]
  } else {
    ^
./utilities/misc.hpp:762:13: warning: function 'format_bitstr' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
std::string format_bitstr(std::string str, const creg_t &regs) {
            ^
inline 
./utilities/misc.hpp:763:20: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (regs.empty())
                   ^
./utilities/misc.hpp:765:3: warning: don't use else after return [readability-else-after-return]
  else {
  ^
./utilities/misc.hpp:767:5: warning: consider replacing 'unsigned long' with 'uint64' [google-runtime-int]
    unsigned long n = 0;
    ^
./utilities/misc.hpp:768:32: warning: statement should be inside braces [readability-braces-around-statements]
    for (const auto &sz : regs)
                               ^
./utilities/misc.hpp:776:5: warning: consider replacing 'unsigned long' with 'uint64' [google-runtime-int]
    unsigned long shift = 0;
    ^
./utilities/misc.hpp:778:39: warning: statement should be inside braces [readability-braces-around-statements]
      for (uint_t j = 0; j != sz; ++j)
                                      ^
./utilities/misc.hpp:783:22: warning: statement should be inside braces [readability-braces-around-statements]
    if (!ret.empty())
                     ^
./utilities/misc.hpp:789:8: warning: function 'vec2ket' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cket_t vec2ket(const cvector_t &psi, uint_t dit, double epsilon,
       ^
inline 
./utilities/misc.hpp:816:8: warning: function 'vec2ket' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cket_t vec2ket(const cvector_t &psi, uint_t dit, double epsilon) {
       ^
inline 
./utilities/misc.hpp:821:8: warning: function 'vec2ket' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cket_t vec2ket(const cvector_t &psi, double epsilon) {
       ^
inline 
./utilities/misc.hpp:829:11: warning: function 'qudit_unitary1' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cmatrix_t qudit_unitary1(const cmatrix_t &U1, uint_t dit) {
          ^
inline 
./utilities/misc.hpp:831:16: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (dit == 2)
               ^
./utilities/misc.hpp:833:3: warning: don't use else after return [readability-else-after-return]
  else {
  ^
./utilities/misc.hpp:837:36: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (uint_t i = 0; i != 2; ++i)
                                   ^
./utilities/misc.hpp:838:38: warning: statement should be inside braces [google-readability-braces-around-statements]
      for (uint_t j = 0; j != 2; ++j)
                                     ^
./utilities/misc.hpp:845:11: warning: function 'qudit_unitary2' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
cmatrix_t qudit_unitary2(const cmatrix_t &U2, uint_t dit) {
          ^
inline 
./utilities/misc.hpp:847:16: warning: statement should be inside braces [readability-braces-around-statements]
  if (dit == 2)
               ^
./utilities/misc.hpp:849:3: warning: don't use else after return [readability-else-after-return]
  else {
  ^
./utilities/misc.hpp:854:36: warning: statement should be inside braces [readability-braces-around-statements]
    for (uint_t i = 0; i != 2; ++i)
                                   ^
./utilities/qubit_vector.hpp:32:1: warning: #includes are not sorted properly [llvm-include-order]
#include <string>
^
./utilities/qubit_vector.hpp:44:19: warning: consider replacing 'long long' with 'int64' [google-runtime-int]
using omp_int_t = long long int; // signed int for OpenMP 2.0 on msvc
                  ^
./utilities/qubit_vector.hpp:63:3: warning: function 'QV::QubitVector::QubitVector' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  QubitVector(size_t num_qubits = 0);
  ^
                     num_qubits_
./utilities/qubit_vector.hpp:276:14: note: the definition seen here
QubitVector::QubitVector(size_t num_qubits_) : num_qubits(num_qubits_),
             ^
./utilities/qubit_vector.hpp:63:3: note: differing parameters are named here: ('num_qubits'), in definition: ('num_qubits_')
  QubitVector(size_t num_qubits = 0);
  ^
./utilities/qubit_vector.hpp:63:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  QubitVector(size_t num_qubits = 0);
  ^
  explicit 
./utilities/qubit_vector.hpp:64:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  QubitVector(const cvector_t &vec);
  ^
  explicit 
./utilities/qubit_vector.hpp:65:3: warning: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [google-explicit-constructor]
  QubitVector(const rvector_t &vec);
  ^
  explicit 
./utilities/qubit_vector.hpp:93:13: warning: function 'QV::QubitVector::probabilities' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  rvector_t probabilities(const std::vector<uint_t> &qubits) const;
            ^
                                                     qs
./utilities/qubit_vector.hpp:1545:24: note: the definition seen here
rvector_t QubitVector::probabilities(const std::vector<uint_t> &qs) const {
                       ^
./utilities/qubit_vector.hpp:93:13: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  rvector_t probabilities(const std::vector<uint_t> &qubits) const;
            ^
./utilities/qubit_vector.hpp:95:13: warning: function 'QV::QubitVector::probabilities' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  rvector_t probabilities(const std::array<uint_t, N> &qubits) const;
            ^
                                                       qs
./utilities/qubit_vector.hpp:1516:24: note: the definition seen here
rvector_t QubitVector::probabilities(const std::array<uint_t, N> &qs) const {
                       ^
./utilities/qubit_vector.hpp:95:13: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  rvector_t probabilities(const std::array<uint_t, N> &qubits) const;
            ^
./utilities/qubit_vector.hpp:102:10: warning: function 'QV::QubitVector::probability' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  double probability(const std::vector<uint_t> &qubits, const uint_t outcome) const;
         ^
                                                qs
./utilities/qubit_vector.hpp:1657:21: note: the definition seen here
double QubitVector::probability(const std::vector<uint_t> &qs,
                    ^
./utilities/qubit_vector.hpp:102:10: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  double probability(const std::vector<uint_t> &qubits, const uint_t outcome) const;
         ^
./utilities/qubit_vector.hpp:104:10: warning: function 'QV::QubitVector::probability' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  double probability(const std::array<uint_t, N> &qubits, const uint_t outcome) const;
         ^
                                                  qs
./utilities/qubit_vector.hpp:1633:21: note: the definition seen here
double QubitVector::probability(const std::array<uint_t, N> &qs,
                    ^
./utilities/qubit_vector.hpp:104:10: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  double probability(const std::array<uint_t, N> &qubits, const uint_t outcome) const;
         ^
./utilities/qubit_vector.hpp:113:8: warning: function 'QV::QubitVector::apply_matrix' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void apply_matrix(const std::vector<uint_t> &qubits, const cvector_t &mat);
       ^
                                               qs
./utilities/qubit_vector.hpp:1188:19: note: the definition seen here
void QubitVector::apply_matrix(const std::vector<uint_t> &qs, const cvector_t &mat) {
                  ^
./utilities/qubit_vector.hpp:113:8: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  void apply_matrix(const std::vector<uint_t> &qubits, const cvector_t &mat);
       ^
./utilities/qubit_vector.hpp:115:8: warning: function 'QV::QubitVector::apply_matrix' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void apply_matrix(const std::array<uint_t, N> &qubits, const cvector_t &mat);
       ^
                                                 qs
./utilities/qubit_vector.hpp:893:19: note: the definition seen here
void QubitVector::apply_matrix(const std::array<uint_t, N> &qs, const cvector_t &mat) {
                  ^
./utilities/qubit_vector.hpp:115:8: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  void apply_matrix(const std::array<uint_t, N> &qubits, const cvector_t &mat);
       ^
./utilities/qubit_vector.hpp:118:8: warning: function 'QV::QubitVector::apply_cnot' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void apply_cnot(const uint_t qctrl, const uint_t qtrgt);
       ^
                               qubit_ctrl          qubit_trgt
./utilities/qubit_vector.hpp:965:19: note: the definition seen here
void QubitVector::apply_cnot(const uint_t qubit_ctrl, const uint_t qubit_trgt) {
                  ^
./utilities/qubit_vector.hpp:118:8: note: differing parameters are named here: ('qctrl', 'qtrgt'), in definition: ('qubit_ctrl', 'qubit_trgt')
  void apply_cnot(const uint_t qctrl, const uint_t qtrgt);
       ^
./utilities/qubit_vector.hpp:119:8: warning: function 'QV::QubitVector::apply_cz' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void apply_cz(const uint_t q0, const uint_t q1);
       ^
                             qubit_ctrl       qubit_trgt
./utilities/qubit_vector.hpp:992:19: note: the definition seen here
void QubitVector::apply_cz(const uint_t qubit_ctrl, const uint_t qubit_trgt) {
                  ^
./utilities/qubit_vector.hpp:119:8: note: differing parameters are named here: ('q0', 'q1'), in definition: ('qubit_ctrl', 'qubit_trgt')
  void apply_cz(const uint_t q0, const uint_t q1);
       ^
./utilities/qubit_vector.hpp:129:10: warning: function 'QV::QubitVector::norm' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  double norm(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
         ^
                                         qs
./utilities/qubit_vector.hpp:1284:21: note: the definition seen here
double QubitVector::norm(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                    ^
./utilities/qubit_vector.hpp:129:10: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  double norm(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
         ^
./utilities/qubit_vector.hpp:131:10: warning: function 'QV::QubitVector::norm' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  double norm(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
         ^
                                           qs
./utilities/qubit_vector.hpp:1022:21: note: the definition seen here
double QubitVector::norm(const std::array<uint_t, N> &qs, const cvector_t &mat) const {
                    ^
./utilities/qubit_vector.hpp:131:10: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  double norm(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
         ^
./utilities/qubit_vector.hpp:138:13: warning: function 'QV::QubitVector::expectation_value' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  complex_t expectation_value(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
            ^
                                                         qs
./utilities/qubit_vector.hpp:1375:24: note: the definition seen here
complex_t QubitVector::expectation_value(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                       ^
./utilities/qubit_vector.hpp:138:13: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  complex_t expectation_value(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
            ^
./utilities/qubit_vector.hpp:140:13: warning: function 'QV::QubitVector::expectation_value' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  complex_t expectation_value(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
            ^
                                                           qs
./utilities/qubit_vector.hpp:1100:24: note: the definition seen here
complex_t QubitVector::expectation_value(const std::array<uint_t, N> &qs, const cvector_t &mat) const {
                       ^
./utilities/qubit_vector.hpp:140:13: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  complex_t expectation_value(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
            ^
./utilities/qubit_vector.hpp:188:8: warning: function 'QV::QubitVector::apply_matrix_col_major' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void apply_matrix_col_major(const std::array<uint_t, N> &qubits, const cvector_t &mat);
       ^
                                                           qs
./utilities/qubit_vector.hpp:901:19: note: the definition seen here
void QubitVector::apply_matrix_col_major(const std::array<uint_t, N> &qs,
                  ^
./utilities/qubit_vector.hpp:188:8: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  void apply_matrix_col_major(const std::array<uint_t, N> &qubits, const cvector_t &mat);
       ^
./utilities/qubit_vector.hpp:190:8: warning: function 'QV::QubitVector::apply_matrix_diagonal' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void apply_matrix_diagonal(const uint_t qubit, const cvector_t &mat);
       ^
                                                                  diag
./utilities/qubit_vector.hpp:591:19: note: the definition seen here
void QubitVector::apply_matrix_diagonal(const uint_t qubit, const cvector_t &diag) {
                  ^
./utilities/qubit_vector.hpp:190:8: note: differing parameters are named here: ('mat'), in definition: ('diag')
  void apply_matrix_diagonal(const uint_t qubit, const cvector_t &mat);
       ^
./utilities/qubit_vector.hpp:191:8: warning: function 'QV::QubitVector::apply_matrix_diagonal' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void apply_matrix_diagonal(const std::vector<uint_t> &qubits, const cvector_t &mat);
       ^
                                                                                 diag
./utilities/qubit_vector.hpp:1251:19: note: the definition seen here
void QubitVector::apply_matrix_diagonal(const std::vector<uint_t> &qubits,
                  ^
./utilities/qubit_vector.hpp:191:8: note: differing parameters are named here: ('mat'), in definition: ('diag')
  void apply_matrix_diagonal(const std::vector<uint_t> &qubits, const cvector_t &mat);
       ^
./utilities/qubit_vector.hpp:193:8: warning: function 'QV::QubitVector::apply_matrix_diagonal' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void apply_matrix_diagonal(const std::array<uint_t, N> &qubits, const cvector_t &mat);
       ^
                                                          qs                       diag
./utilities/qubit_vector.hpp:938:19: note: the definition seen here
void QubitVector::apply_matrix_diagonal(const std::array<uint_t, N> &qs,
                  ^
./utilities/qubit_vector.hpp:193:8: note: differing parameters are named here: ('qubits', 'mat'), in definition: ('qs', 'diag')
  void apply_matrix_diagonal(const std::array<uint_t, N> &qubits, const cvector_t &mat);
       ^
./utilities/qubit_vector.hpp:199:10: warning: function 'QV::QubitVector::norm_matrix' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  double norm_matrix(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
         ^
                                                qs
./utilities/qubit_vector.hpp:1305:21: note: the definition seen here
double QubitVector::norm_matrix(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                    ^
./utilities/qubit_vector.hpp:199:10: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  double norm_matrix(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
         ^
./utilities/qubit_vector.hpp:200:10: warning: function 'QV::QubitVector::norm_matrix_diagonal' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  double norm_matrix_diagonal(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
         ^
                                                         qs
./utilities/qubit_vector.hpp:1339:21: note: the definition seen here
double QubitVector::norm_matrix_diagonal(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                    ^
./utilities/qubit_vector.hpp:200:10: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  double norm_matrix_diagonal(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
         ^
./utilities/qubit_vector.hpp:202:10: warning: function 'QV::QubitVector::norm_matrix' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  double norm_matrix(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
         ^
                                                  qs
./utilities/qubit_vector.hpp:1030:21: note: the definition seen here
double QubitVector::norm_matrix(const std::array<uint_t, N> &qs, const cvector_t &mat) const {
                    ^
./utilities/qubit_vector.hpp:202:10: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  double norm_matrix(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
         ^
./utilities/qubit_vector.hpp:204:10: warning: function 'QV::QubitVector::norm_matrix_diagonal' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  double norm_matrix_diagonal(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
         ^
                                                           qs
./utilities/qubit_vector.hpp:1065:21: note: the definition seen here
double QubitVector::norm_matrix_diagonal(const std::array<uint_t, N> &qs, const cvector_t &mat) const {
                    ^
./utilities/qubit_vector.hpp:204:10: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  double norm_matrix_diagonal(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
         ^
./utilities/qubit_vector.hpp:210:13: warning: function 'QV::QubitVector::expectation_value_matrix' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  complex_t expectation_value_matrix(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
            ^
                                                                qs
./utilities/qubit_vector.hpp:1396:24: note: the definition seen here
complex_t QubitVector::expectation_value_matrix(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                       ^
./utilities/qubit_vector.hpp:210:13: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  complex_t expectation_value_matrix(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
            ^
./utilities/qubit_vector.hpp:211:13: warning: function 'QV::QubitVector::expectation_value_matrix_diagonal' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  complex_t expectation_value_matrix_diagonal(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
            ^
                                                                         qs
./utilities/qubit_vector.hpp:1432:24: note: the definition seen here
complex_t QubitVector::expectation_value_matrix_diagonal(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                       ^
./utilities/qubit_vector.hpp:211:13: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  complex_t expectation_value_matrix_diagonal(const std::vector<uint_t> &qubits, const cvector_t &mat) const;
            ^
./utilities/qubit_vector.hpp:213:13: warning: function 'QV::QubitVector::expectation_value_matrix' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  complex_t expectation_value_matrix(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
            ^
                                                                  qs
./utilities/qubit_vector.hpp:1108:24: note: the definition seen here
complex_t QubitVector::expectation_value_matrix(const std::array<uint_t, N> &qs, const cvector_t &mat) const {
                       ^
./utilities/qubit_vector.hpp:213:13: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  complex_t expectation_value_matrix(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
            ^
./utilities/qubit_vector.hpp:215:13: warning: function 'QV::QubitVector::expectation_value_matrix_diagonal' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  complex_t expectation_value_matrix_diagonal(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
            ^
                                                                           qs
./utilities/qubit_vector.hpp:1145:24: note: the definition seen here
complex_t QubitVector::expectation_value_matrix_diagonal(const std::array<uint_t, N> &qs, const cvector_t &mat) const {
                       ^
./utilities/qubit_vector.hpp:215:13: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  complex_t expectation_value_matrix_diagonal(const std::array<uint_t, N> &qubits, const cvector_t &mat) const;
            ^
./utilities/qubit_vector.hpp:219:8: warning: function 'QV::QubitVector::check_vector' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void check_vector(const cvector_t &diag, uint_t nqubits) const;
       ^
                                     vec
./utilities/qubit_vector.hpp:253:19: note: the definition seen here
void QubitVector::check_vector(const cvector_t &vec, uint_t nqubits) const {
                  ^
./utilities/qubit_vector.hpp:219:8: note: differing parameters are named here: ('diag'), in definition: ('vec')
  void check_vector(const cvector_t &diag, uint_t nqubits) const;
       ^
./utilities/qubit_vector.hpp:220:8: warning: function 'QV::QubitVector::check_matrix' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  void check_matrix(const cvector_t &mat, uint_t nqubits) const;
       ^
                                     vec
./utilities/qubit_vector.hpp:243:19: note: the definition seen here
void QubitVector::check_matrix(const cvector_t &vec, uint_t nqubits) const {
                  ^
./utilities/qubit_vector.hpp:220:8: note: differing parameters are named here: ('mat'), in definition: ('vec')
  void check_matrix(const cvector_t &mat, uint_t nqubits) const;
       ^
./utilities/qubit_vector.hpp:235:19: warning: function 'check_qubit' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::check_qubit(const uint_t qubit) const {
                  ^
inline 
./utilities/qubit_vector.hpp:243:19: warning: function 'check_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::check_matrix(const cvector_t &vec, uint_t nqubits) const {
                  ^
inline 
./utilities/qubit_vector.hpp:253:19: warning: function 'check_vector' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::check_vector(const cvector_t &vec, uint_t nqubits) const {
                  ^
inline 
./utilities/qubit_vector.hpp:263:19: warning: function 'check_dimension' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::check_dimension(const QubitVector &qv) const {
                  ^
inline 
./utilities/qubit_vector.hpp:276:14: warning: function 'QubitVector' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector::QubitVector(size_t num_qubits_) : num_qubits(num_qubits_),
             ^
inline 
./utilities/qubit_vector.hpp:283:14: warning: function 'QubitVector' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector::QubitVector(const cvector_t &vec) : QubitVector() {
             ^
inline 
./utilities/qubit_vector.hpp:287:14: warning: function 'QubitVector' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector::QubitVector(const rvector_t &vec) : QubitVector() {
             ^
inline 
./utilities/qubit_vector.hpp:298:25: warning: function 'operator[]' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t &QubitVector::operator[](uint_t element) {
                        ^
inline 
./utilities/qubit_vector.hpp:312:24: warning: function 'operator[]' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t QubitVector::operator[](uint_t element) const {
                       ^
inline 
./utilities/qubit_vector.hpp:326:27: warning: function 'operator=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector &QubitVector::operator=(const cvector_t &vec) {
                          ^
inline 
./utilities/qubit_vector.hpp:332:10: warning: implicit cast 'uint_t' -> bool [readability-implicit-bool-cast]
  while (size >>= 1) ++num_qubits;
         ^
                    != 0u
./utilities/qubit_vector.hpp:332:21: warning: statement should be inside braces [readability-braces-around-statements]
  while (size >>= 1) ++num_qubits;
                    ^
./utilities/qubit_vector.hpp:347:27: warning: function 'operator=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector &QubitVector::operator=(const rvector_t &vec) {
                          ^
inline 
./utilities/qubit_vector.hpp:353:10: warning: implicit cast 'uint_t' -> bool [readability-implicit-bool-cast]
  while (size >>= 1) ++num_qubits;
         ^
                    != 0u
./utilities/qubit_vector.hpp:353:21: warning: statement should be inside braces [readability-braces-around-statements]
  while (size >>= 1) ++num_qubits;
                    ^
./utilities/qubit_vector.hpp:366:27: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (const auto& v: vec)
                          ^
./utilities/qubit_vector.hpp:372:27: warning: function 'operator*=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector &QubitVector::operator*=(const complex_t &lambda) {
                          ^
inline 
./utilities/qubit_vector.hpp:377:40: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k = 0; k < end; k++)
                                       ^
./utilities/qubit_vector.hpp:383:27: warning: function 'operator*=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector &QubitVector::operator*=(const double &lambda) {
                          ^
inline 
./utilities/qubit_vector.hpp:388:13: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector operator*(const complex_t &lambda, const QubitVector &qv) {
            ^
inline 
./utilities/qubit_vector.hpp:394:13: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector operator*(const QubitVector &qv, const complex_t &lambda) {
            ^
inline 
./utilities/qubit_vector.hpp:398:13: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector operator*(const double &lambda, const QubitVector &qv) {
            ^
inline 
./utilities/qubit_vector.hpp:402:13: warning: function 'operator*' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector operator*(const QubitVector &qv, const double &lambda) {
            ^
inline 
./utilities/qubit_vector.hpp:408:27: warning: function 'operator+=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector &QubitVector::operator+=(const QubitVector &qv) {
                          ^
inline 
./utilities/qubit_vector.hpp:417:40: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k = 0; k < end; k++)
                                       ^
./utilities/qubit_vector.hpp:423:26: warning: function 'operator+' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector QubitVector::operator+(const QubitVector &qv) const{
                         ^
inline 
./utilities/qubit_vector.hpp:431:27: warning: function 'operator-=' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector &QubitVector::operator-=(const QubitVector &qv) {
                          ^
inline 
./utilities/qubit_vector.hpp:440:40: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k = 0; k < end; k++)
                                       ^
./utilities/qubit_vector.hpp:446:26: warning: function 'operator-' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
QubitVector QubitVector::operator-(const QubitVector &qv) const{
                         ^
inline 
./utilities/qubit_vector.hpp:457:19: warning: function 'initialize' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::initialize() {
                  ^
inline 
./utilities/qubit_vector.hpp:462:19: warning: function 'initialize_plus' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::initialize_plus() {
                  ^
inline 
./utilities/qubit_vector.hpp:467:19: warning: function 'conj' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::conj() {
                  ^
inline 
./utilities/qubit_vector.hpp:478:24: warning: function 'dot' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t QubitVector::dot(const QubitVector &qv) const {
                       ^
inline 
./utilities/qubit_vector.hpp:499:24: warning: function 'inner_product' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t QubitVector::inner_product(const QubitVector &qv) const {
                       ^
inline 
./utilities/qubit_vector.hpp:519:19: warning: function 'renormalize' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::renormalize() {
                  ^
inline 
./utilities/qubit_vector.hpp:534:19: warning: function 'set_omp_threads' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::set_omp_threads(int n) {
                  ^
inline 
./utilities/qubit_vector.hpp:535:13: warning: statement should be inside braces [readability-braces-around-statements]
  if (n > 0)
            ^
./utilities/qubit_vector.hpp:539:19: warning: function 'set_omp_threshold' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::set_omp_threshold(int n) {
                  ^
inline 
./utilities/qubit_vector.hpp:540:13: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (n > 0)
            ^
./utilities/qubit_vector.hpp:555:19: warning: function 'apply_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_matrix(const uint_t qubit, const cvector_t &mat) {
                  ^
inline 
./utilities/qubit_vector.hpp:556:23: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (mat.size() == 2)
                      ^
./utilities/qubit_vector.hpp:558:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:562:19: warning: function 'apply_matrix_col_major' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_matrix_col_major(const uint_t qubit, const cvector_t &mat) {
                  ^
inline 
./utilities/qubit_vector.hpp:580:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:591:19: warning: function 'apply_matrix_diagonal' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_matrix_diagonal(const uint_t qubit, const cvector_t &diag) {
                  ^
inline 
./utilities/qubit_vector.hpp:610:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:619:19: warning: function 'apply_x' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_x(const uint_t qubit) {
                  ^
inline 
./utilities/qubit_vector.hpp:637:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:648:19: warning: function 'apply_y' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_y(const uint_t qubit) {
                  ^
inline 
./utilities/qubit_vector.hpp:666:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:677:19: warning: function 'apply_z' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_z(const uint_t qubit) {
                  ^
inline 
./utilities/qubit_vector.hpp:696:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:709:21: warning: function 'norm' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::norm() const {
                    ^
inline 
./utilities/qubit_vector.hpp:715:40: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k = 0; k < end; k++)
                                       ^
./utilities/qubit_vector.hpp:721:21: warning: function 'norm' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::norm(const uint_t qubit, const cvector_t &mat) const {
                    ^
inline 
./utilities/qubit_vector.hpp:722:23: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (mat.size() == 2)
                      ^
./utilities/qubit_vector.hpp:724:3: warning: don't use else after return [readability-else-after-return]
  else
  ^
./utilities/qubit_vector.hpp:724:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:728:21: warning: function 'norm_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::norm_matrix(const uint_t qubit, const cvector_t &mat) const {
                    ^
inline 
./utilities/qubit_vector.hpp:748:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:761:21: warning: function 'norm_matrix_diagonal' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::norm_matrix_diagonal(const uint_t qubit, const cvector_t &mat) const {
                    ^
inline 
./utilities/qubit_vector.hpp:781:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:797:24: warning: function 'expectation_value' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t QubitVector::expectation_value(const uint_t qubit, const cvector_t &mat) const {
                       ^
inline 
./utilities/qubit_vector.hpp:798:23: warning: statement should be inside braces [readability-braces-around-statements]
  if (mat.size() == 2)
                      ^
./utilities/qubit_vector.hpp:800:3: warning: don't use else after return [readability-else-after-return]
  else
  ^
./utilities/qubit_vector.hpp:800:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:804:24: warning: function 'expectation_value_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t QubitVector::expectation_value_matrix(const uint_t qubit, const cvector_t &mat) const {
                       ^
inline 
./utilities/qubit_vector.hpp:825:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:840:24: warning: function 'expectation_value_matrix_diagonal' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t QubitVector::expectation_value_matrix_diagonal(const uint_t qubit, const cvector_t &mat) const {
                       ^
inline 
./utilities/qubit_vector.hpp:860:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:884:19: warning: function 'apply_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_matrix(const uint_t qubit0, const uint_t qubit1,
                  ^
inline 
./utilities/qubit_vector.hpp:886:23: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (mat.size() == 4)
                      ^
./utilities/qubit_vector.hpp:888:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:894:33: warning: statement should be inside braces [readability-braces-around-statements]
  if (mat.size() == (1ULL << N))
                                ^
./utilities/qubit_vector.hpp:896:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:925:25: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        const auto ii = inds[i];
                        ^
./utilities/qubit_vector.hpp:926:9: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        cache[i] = state_vector[ii];
        ^
./utilities/qubit_vector.hpp:930:39: warning: statement should be inside braces [readability-braces-around-statements]
      for (size_t i = 0; i < dim; i++)
                                      ^
./utilities/qubit_vector.hpp:931:41: warning: statement should be inside braces [readability-braces-around-statements]
        for (size_t j = 0; j < dim; j++)
                                        ^
./utilities/qubit_vector.hpp:932:24: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
          state_vector[inds[i]] += mat[i + dim * j] * cache[j];
                       ^
./utilities/qubit_vector.hpp:932:55: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
          state_vector[inds[i]] += mat[i + dim * j] * cache[j];
                                                      ^
./utilities/qubit_vector.hpp:959:39: warning: statement should be inside braces [readability-braces-around-statements]
      for (size_t i = 0; i < dim; i++)
                                      ^
./utilities/qubit_vector.hpp:960:24: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
          state_vector[inds[i]] *= diag[i];
                       ^
./utilities/qubit_vector.hpp:965:19: warning: function 'apply_cnot' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_cnot(const uint_t qubit_ctrl, const uint_t qubit_trgt) {
                  ^
inline 
./utilities/qubit_vector.hpp:992:19: warning: function 'apply_cz' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_cz(const uint_t qubit_ctrl, const uint_t qubit_trgt) {
                  ^
inline 
./utilities/qubit_vector.hpp:1023:33: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (mat.size() == (1ULL << N))
                                ^
./utilities/qubit_vector.hpp:1025:3: warning: don't use else after return [readability-else-after-return]
  else
  ^
./utilities/qubit_vector.hpp:1025:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:1054:41: warning: statement should be inside braces [google-readability-braces-around-statements]
        for (size_t j = 0; j < dim; j++)
                                        ^
./utilities/qubit_vector.hpp:1055:49: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
          vi += mat[i + dim * j] * state_vector[inds[j]];
                                                ^
./utilities/qubit_vector.hpp:1087:47: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        const auto vi = mat[i] * state_vector[inds[i]];
                                              ^
./utilities/qubit_vector.hpp:1101:33: warning: statement should be inside braces [readability-braces-around-statements]
  if (mat.size() == (1ULL << N))
                                ^
./utilities/qubit_vector.hpp:1103:3: warning: don't use else after return [readability-else-after-return]
  else
  ^
./utilities/qubit_vector.hpp:1103:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:1132:49: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
          vi += mat[i + dim * j] * state_vector[inds[j]];
                                                ^
./utilities/qubit_vector.hpp:1134:59: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        const complex_t val = vi * std::conj(state_vector[inds[i]]);
                                                          ^
./utilities/qubit_vector.hpp:1167:41: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
        const auto cache = state_vector[inds[i]];
                                        ^
./utilities/qubit_vector.hpp:1188:19: warning: function 'apply_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_matrix(const std::vector<uint_t> &qs, const cvector_t &mat) {
                  ^
inline 
./utilities/qubit_vector.hpp:1208:41: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (mat.size() == (1ULL << qs.size()))
                                        ^
./utilities/qubit_vector.hpp:1210:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:1214:19: warning: function 'apply_matrix_col_major' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_matrix_col_major(const std::vector<uint_t> &qubits, const cvector_t &mat) {
                  ^
inline 
./utilities/qubit_vector.hpp:1244:39: warning: statement should be inside braces [readability-braces-around-statements]
      for (size_t i = 0; i < dim; i++)
                                      ^
./utilities/qubit_vector.hpp:1245:41: warning: statement should be inside braces [readability-braces-around-statements]
        for (size_t j = 0; j < dim; j++)
                                        ^
./utilities/qubit_vector.hpp:1251:19: warning: function 'apply_matrix_diagonal' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QubitVector::apply_matrix_diagonal(const std::vector<uint_t> &qubits,
                  ^
inline 
./utilities/qubit_vector.hpp:1273:39: warning: statement should be inside braces [readability-braces-around-statements]
      for (size_t i = 0; i < dim; i++)
                                      ^
./utilities/qubit_vector.hpp:1284:21: warning: function 'norm' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::norm(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                    ^
inline 
./utilities/qubit_vector.hpp:1299:41: warning: statement should be inside braces [google-readability-braces-around-statements]
  if (mat.size() == (1ULL << qs.size()))
                                        ^
./utilities/qubit_vector.hpp:1301:3: warning: don't use else after return [readability-else-after-return]
  else
  ^
./utilities/qubit_vector.hpp:1301:7: warning: statement should be inside braces [google-readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:1305:21: warning: function 'norm_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::norm_matrix(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                    ^
inline 
./utilities/qubit_vector.hpp:1330:41: warning: statement should be inside braces [google-readability-braces-around-statements]
        for (size_t j = 0; j < dim; j++)
                                        ^
./utilities/qubit_vector.hpp:1339:21: warning: function 'norm_matrix_diagonal' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::norm_matrix_diagonal(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                    ^
inline 
./utilities/qubit_vector.hpp:1375:24: warning: function 'expectation_value' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t QubitVector::expectation_value(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                       ^
inline 
./utilities/qubit_vector.hpp:1390:41: warning: statement should be inside braces [readability-braces-around-statements]
  if (mat.size() == (1ULL << qs.size()))
                                        ^
./utilities/qubit_vector.hpp:1392:3: warning: don't use else after return [readability-else-after-return]
  else
  ^
./utilities/qubit_vector.hpp:1392:7: warning: statement should be inside braces [readability-braces-around-statements]
  else
      ^
./utilities/qubit_vector.hpp:1396:24: warning: function 'expectation_value_matrix' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t QubitVector::expectation_value_matrix(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                       ^
inline 
./utilities/qubit_vector.hpp:1432:24: warning: function 'expectation_value_matrix_diagonal' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
complex_t QubitVector::expectation_value_matrix_diagonal(const std::vector<uint_t> &qs, const cvector_t &mat) const {
                       ^
inline 
./utilities/qubit_vector.hpp:1476:24: warning: function 'probabilities' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t QubitVector::probabilities() const {
                       ^
inline 
./utilities/qubit_vector.hpp:1486:24: warning: function 'probabilities' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t QubitVector::probabilities(const uint_t qubit) const {
                       ^
inline 
./utilities/qubit_vector.hpp:1505:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:1524:14: warning: statement should be inside braces [readability-braces-around-statements]
  if (N == 0)
             ^
./utilities/qubit_vector.hpp:1532:40: warning: statement should be inside braces [google-readability-braces-around-statements]
  if ((N == num_qubits) && (qs == qss))
                                       ^
./utilities/qubit_vector.hpp:1539:31: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
      probs[m] += probability(indexes[m]);
                              ^
./utilities/qubit_vector.hpp:1545:24: warning: function 'probabilities' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
rvector_t QubitVector::probabilities(const std::vector<uint_t> &qs) const {
                       ^
inline 
./utilities/qubit_vector.hpp:1574:40: warning: statement should be inside braces [readability-braces-around-statements]
  if ((N == num_qubits) && (qss == qs))
                                       ^
./utilities/qubit_vector.hpp:1581:37: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t m = 0; m < dim; ++m)
                                    ^
./utilities/qubit_vector.hpp:1590:21: warning: function 'probability' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::probability(const uint_t outcome) const {
                    ^
inline 
./utilities/qubit_vector.hpp:1595:21: warning: function 'probability' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::probability(const uint_t qubit, const uint_t outcome) const {
                    ^
inline 
./utilities/qubit_vector.hpp:1615:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:1616:46: warning: statement should be inside braces [google-readability-braces-around-statements]
      for (omp_int_t k2 = 0; k2 < end2; k2++)
                                             ^
./utilities/qubit_vector.hpp:1624:51: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k1 = 0; k1 < end1; k1 += step1)
                                                  ^
./utilities/qubit_vector.hpp:1625:46: warning: statement should be inside braces [google-readability-braces-around-statements]
      for (omp_int_t k2 = 0; k2 < end2; k2++)
                                             ^
./utilities/qubit_vector.hpp:1651:40: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k = 0; k < end; k++)
                                       ^
./utilities/qubit_vector.hpp:1652:24: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
      p += probability(idx.indexes_static<N>(qs, qubits_sorted, k)[outcome]);
                       ^
./utilities/qubit_vector.hpp:1657:21: warning: function 'probability' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
double QubitVector::probability(const std::vector<uint_t> &qs,
                    ^
inline 
./utilities/qubit_vector.hpp:1692:40: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (omp_int_t k = 0; k < end; k++)
                                       ^
./utilities/tensor_index.hpp:30:1: warning: #includes are not sorted properly [llvm-include-order]
#include <vector>
^
./utilities/tensor_index.hpp:33:1: warning: missing username/bug in TODO [google-readability-todo]
// TODO -- add support for qudit indexing
^
// TODO(jgomez): -- add support for qudit indexing
./utilities/tensor_index.hpp:37:18: warning: consider replacing 'unsigned long long' with 'uint64' [google-runtime-int]
  using uint_t = unsigned long long;
                 ^
./utilities/tensor_index.hpp:65:23: warning: function 'TI::TensorIndex::indexes_dynamic' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  std::vector<uint_t> indexes_dynamic(const std::vector<uint_t> &qubitss,
                      ^
                                                                 qs
./utilities/tensor_index.hpp:186:14: note: the definition seen here
TensorIndex::indexes_dynamic(const std::vector<uint_t> &qs,
             ^
./utilities/tensor_index.hpp:65:23: note: differing parameters are named here: ('qubitss'), in definition: ('qs')
  std::vector<uint_t> indexes_dynamic(const std::vector<uint_t> &qubitss,
                      ^
./utilities/tensor_index.hpp:76:33: warning: function 'TI::TensorIndex::indexes_static' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  std::array<uint_t, 1ULL << N> indexes_static(const std::array<uint_t, N> &qubitss,
                                ^
                                                                            qs
./utilities/tensor_index.hpp:132:14: note: the definition seen here
TensorIndex::indexes_static(const std::array<uint_t, N> &qs,
             ^
./utilities/tensor_index.hpp:76:33: note: differing parameters are named here: ('qubitss'), in definition: ('qs')
  std::array<uint_t, 1ULL << N> indexes_static(const std::array<uint_t, N> &qubitss,
                                ^
./utilities/tensor_index.hpp:79:25: warning: function 'TI::TensorIndex::indexes_static' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  std::array<uint_t, 4> indexes_static(const std::array<uint_t, 2> &qubits,
                        ^
                                                                    qs
./utilities/tensor_index.hpp:157:14: note: the definition seen here
TensorIndex::indexes_static(const std::array<uint_t, 2> &qs,
             ^
./utilities/tensor_index.hpp:79:25: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  std::array<uint_t, 4> indexes_static(const std::array<uint_t, 2> &qubits,
                        ^
./utilities/tensor_index.hpp:83:25: warning: function 'TI::TensorIndex::indexes_static' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name]
  std::array<uint_t, 2> indexes_static(const std::array<uint_t, 1> &qubits,
                        ^
                                                                    qs
./utilities/tensor_index.hpp:147:14: note: the definition seen here
TensorIndex::indexes_static(const std::array<uint_t, 1> &qs,
             ^
./utilities/tensor_index.hpp:83:25: note: differing parameters are named here: ('qubits'), in definition: ('qs')
  std::array<uint_t, 2> indexes_static(const std::array<uint_t, 1> &qubits,
                        ^
./utilities/tensor_index.hpp:104:14: warning: function 'TensorIndex' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
TensorIndex::TensorIndex() {
             ^
inline 
./utilities/tensor_index.hpp:106:34: warning: statement should be inside braces [readability-braces-around-statements]
  for (uint_t i = 0; i < 64; i++)
                                 ^
./utilities/tensor_index.hpp:107:5: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    masks[i] = (1ULL << i) - 1;
    ^
./utilities/tensor_index.hpp:108:34: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (uint_t i = 0; i < 64; i++)
                                 ^
./utilities/tensor_index.hpp:109:5: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    bits[i] = (1ULL << i);
    ^
./utilities/tensor_index.hpp:121:13: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    mask ^= masks[qubits_sorted[j] - j];
            ^
./utilities/tensor_index.hpp:121:19: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    mask ^= masks[qubits_sorted[j] - j];
                  ^
./utilities/tensor_index.hpp:139:22: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    const auto bit = bits[qs[i]];
                     ^
./utilities/tensor_index.hpp:139:27: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    const auto bit = bits[qs[i]];
                          ^
./utilities/tensor_index.hpp:140:35: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (size_t j = 0; j < n; j++)
                                  ^
./utilities/tensor_index.hpp:141:7: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
      ret[n + j] = ret[j] | bit;
      ^
./utilities/tensor_index.hpp:141:20: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
      ret[n + j] = ret[j] | bit;
                   ^
./utilities/tensor_index.hpp:147:14: warning: function 'indexes_static' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
TensorIndex::indexes_static(const std::array<uint_t, 1> &qs,
             ^
./utilities/tensor_index.hpp:152:21: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
  ret[1] = ret[0] | bits[qs[0]];
                    ^
./utilities/tensor_index.hpp:157:14: warning: function 'indexes_static' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
TensorIndex::indexes_static(const std::array<uint_t, 2> &qs,
             ^
./utilities/tensor_index.hpp:162:21: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
  ret[1] = ret[0] | bits[qs[0]];
                    ^
./utilities/tensor_index.hpp:163:21: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
  ret[2] = ret[0] | bits[qs[1]];
                    ^
./utilities/tensor_index.hpp:164:21: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
  ret[3] = ret[1] | bits[qs[1]];
                    ^
./utilities/tensor_index.hpp:172:21: warning: function 'index0_dynamic' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
uint_t TensorIndex::index0_dynamic(const std::vector<uint_t> &qubits_sorted, const size_t N,
                    ^
inline 
./utilities/tensor_index.hpp:176:13: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    mask ^= masks[qubits_sorted[j] - j];
            ^
./utilities/tensor_index.hpp:186:14: warning: function 'indexes_dynamic' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
TensorIndex::indexes_dynamic(const std::vector<uint_t> &qs,
             ^
./utilities/tensor_index.hpp:193:22: warning: do not use array subscript when the index is not an integer constant expression; use gsl::at() instead [cppcoreguidelines-pro-bounds-constant-array-index]
    const auto bit = bits[qs[i]];
                     ^
./utilities/tensor_index.hpp:194:35: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t j = 0; j < n; j++)
                                  ^
./utilities/tensor_index.hpp:200:2: warning: namespace 'TI' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace TI
./utilities/tensor_index.hpp:35:11: note: namespace 'TI' starts here
namespace TI {
          ^
./utilities/types.hpp:48:15: warning: consider replacing 'long long' with 'int64' [google-runtime-int]
using int_t = long long;
              ^
./utilities/types.hpp:60:1: warning: using declarations in the global namespace in headers are prohibited [google-global-names-in-headers]
using QV::QubitVector;
^
./utilities/types.hpp:289:2: warning: namespace 'QV' not terminated with a closing comment [google-readability-namespace-comments]
}
 ^
   // namespace QV
./utilities/types.hpp:279:11: note: namespace 'QV' starts here
namespace QV {
          ^
./utilities/types.hpp:301:14: warning: function 'load' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
json_t JSON::load(std::string name) {
             ^
inline 
./utilities/types.hpp:307:38: warning: statement should be inside braces [readability-braces-around-statements]
  if (name == "stdin" || name == "-") // Load from stdin
                                     ^
./utilities/types.hpp:323:12: warning: function 'check_key' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool JSON::check_key(std::string key, const json_t &js) {
           ^
inline 
./utilities/types.hpp:325:54: warning: statement should be inside braces [readability-braces-around-statements]
  if (js.find(key) != js.end() && !js[key].is_null())
                                                     ^
./utilities/types.hpp:327:3: warning: don't use else after return [readability-else-after-return]
  else
  ^
./utilities/types.hpp:327:7: warning: statement should be inside braces [readability-braces-around-statements]
  else
      ^
./utilities/types.hpp:331:12: warning: function 'check_keys' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
bool JSON::check_keys(std::vector<std::string> keys, const json_t &js) {
           ^
inline 
./utilities/types.hpp:333:22: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (auto s : keys)
                     ^
./utilities/types.hpp:334:13: warning: implicit cast bool -> 'int' [readability-implicit-bool-cast]
    pass &= check_key(s, js);
            ^
            static_cast<int>( )
./utilities/types.hpp:343:5: warning: don't use else after return [readability-else-after-return]
  } else {
    ^
./utilities/types.hpp:349:6: warning: function 'string_trim' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void string_trim(std::string &str) {
     ^
inline 
./utilities/types.hpp:351:21: warning: statement should be inside braces [google-readability-braces-around-statements]
  for (auto c : str)
                    ^
./utilities/types.hpp:352:42: warning: statement should be inside braces [readability-braces-around-statements]
    if (c != ' ' && c != '_' && c != '-')
                                         ^
./utilities/types.hpp:366:22: warning: statement should be inside braces [readability-braces-around-statements]
  if (js.is_number())
                     ^
./utilities/types.hpp:376:11: warning: function 'to_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void std::to_json(json_t &js, const cvector_t &vec) {
          ^
inline 
./utilities/types.hpp:384:11: warning: function 'from_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void std::from_json(const json_t &js, cvector_t &vec) {
          ^
inline 
./utilities/types.hpp:387:25: warning: statement should be inside braces [readability-braces-around-statements]
    for (auto &elt : js)
                        ^
./utilities/types.hpp:419:38: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (uint_t c = 0; c < cols; c++)
                                     ^
./utilities/types.hpp:432:23: warning: statement should be inside braces [readability-braces-around-statements]
  for (auto &row : js)
                      ^
./utilities/types.hpp:438:38: warning: statement should be inside braces [readability-braces-around-statements]
    for (uint_t r = 0; r < rows; r++)
                                     ^
./utilities/types.hpp:439:40: warning: statement should be inside braces [readability-braces-around-statements]
      for (uint_t c = 0; c < cols; c++)
                                       ^
./utilities/types.hpp:459:6: warning: function 'to_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void to_json(json_t &js, const PauliOperator &p) {
     ^
inline 
./utilities/types.hpp:467:6: warning: function 'from_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void from_json(const json_t &js, PauliOperator &p) {
     ^
inline 
./utilities/types.hpp:482:6: warning: function 'to_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void to_json(json_t &js, const Clifford &clif) {
     ^
inline 
./utilities/types.hpp:487:3: warning: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay]
  assert(2 * n + 1 == table.size());
  ^
/usr/include/assert.h:91:48: note: expanded from macro 'assert'
   : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
                                               ^
/usr/include/assert.h:106:30: note: expanded from macro '__ASSERT_FUNCTION'
#   define __ASSERT_FUNCTION    __PRETTY_FUNCTION__
                                ^
./utilities/types.hpp:496:6: warning: function 'from_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void from_json(const json_t &js, Clifford &clif) {
     ^
inline 
./utilities/types.hpp:504:36: warning: statement should be inside braces [readability-braces-around-statements]
    for (size_t j = 0; j < nq; j++)
                                   ^
./utilities/types.hpp:506:36: warning: statement should be inside braces [google-readability-braces-around-statements]
    for (size_t j = 0; j < nq; j++)
                                   ^
./utilities/types.hpp:523:10: warning: function 'to_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QV::to_json(json_t &js, const QubitVector &qv) {
         ^
inline 
./utilities/types.hpp:527:10: warning: function 'from_json' defined in a header file; function definitions in header files can lead to ODR violations [misc-definitions-in-headers]
void QV::from_json(const json_t &js, QubitVector &qv) {
         ^
inline 
./utilities/types.hpp:551:19: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (i != last)
                  ^
./utilities/types.hpp:564:20: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (i != N - 1)
                   ^
./utilities/types.hpp:578:21: warning: statement should be inside braces [readability-braces-around-statements]
    if (pos != last)
                    ^
./utilities/types.hpp:593:21: warning: statement should be inside braces [google-readability-braces-around-statements]
    if (pos != last)
                    ^
/home/jgomez/ibm/quantum/qiskit-sdk-py/src/qasm-simulator-cpp/src/main.cpp:64:36: warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
     qobj = JSON::load(std::string(argv[1]));
                                   ^
Suppressed 18413 warnings (18413 in non-user code).
Use -header-filter=.* to display errors from all non-system headers.
