:sparkles: Enable QIR support

Open ystade opened this issue 1 year ago • 2 comments

Description

⚠️ This is work in progress! 🚧

QIR is an LLVM IR dialect. This work aims to provide DDsim as a QIR backend. It packs DDsim into a shared library that can be linked with any .ll-file following the QIR specification resulting in an executable.

Checklist:

[ ] The pull request only contains commits that are related to it.
[ ] I have added appropriate tests and documentation.
[ ] I have made sure that all CI jobs on GitHub pass.
[ ] The pull request introduces no new warnings and follows the project's style guidelines.

Jan 18 '24 21:01 ystade

Cpp-Linter Report :warning:

Some files did not pass the configured checks!

clang-tidy reports: 614 concern(s)

include/qir/DDsimQir.h

include/qir/DDsimQir.h:6:10: warning: [modernize-deprecated-headers]

including 'stdbool.h' has no effect in C++; consider removing it
```
#include <stdbool.h>
~~~~~~~~~^~~~~~~~~~~
```
include/qir/DDsimQir.h:21:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef signed long long int Int;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Int = long long
```
include/qir/DDsimQir.h:21:9: warning: [google-runtime-int]

consider replacing 'long long' with 'int64'
```
typedef signed long long int Int;
        ^
```
include/qir/DDsimQir.h:22:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef double               Double;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Double = double
```
include/qir/DDsimQir.h:23:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef bool                 Bool;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Bool = bool
```
include/qir/DDsimQir.h:24:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef enum {
^~~~~~~~~~~~~~
```
include/qir/DDsimQir.h:25:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_I'
```
    PauliId_I = 0,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:26:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_X'
```
    PauliId_X = 1,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:27:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_Z'
```
    PauliId_Z = 2,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:28:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_Y'
```
    PauliId_Y = 3,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:30:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef struct {
^~~~~~~~~~~~~~~~
```
include/qir/DDsimQir.h:37:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void BigInt;
^~~~~~~~~~~~~~~~~~~
using BigInt = void
```
include/qir/DDsimQir.h:42:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Result;
^~~~~~~~~~~~~~~~~~~
using Result = void
```
include/qir/DDsimQir.h:45:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_zero', which is a reserved identifier
```
Result* __quantum__rt__result_get_zero();
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:45:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_zero'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:48:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_one', which is a reserved identifier
```
Result* __quantum__rt__result_get_one();
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:48:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_one'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:51:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_equal', which is a reserved identifier
```
Bool __quantum__rt__result_equal(Result*, Result*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:51:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:55:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_update_reference_count', which is a reserved identifier
```
void __quantum__rt__result_update_reference_count(Result*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:55:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:55:60: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__result_update_reference_count(Result*, long int);
                                                           ^
```
include/qir/DDsimQir.h:59:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Qubit;
^~~~~~~~~~~~~~~~~~
using Qubit = void
```
include/qir/DDsimQir.h:64:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef char String;
^~~~~~~~~~~~~~~~~~~
using String = char
```
include/qir/DDsimQir.h:67:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_create', which is a reserved identifier
```
String* __quantum__rt__string_create(const char*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:67:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:70:13: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_data', which is a reserved identifier
```
const char* __quantum__rt__string_get_data(String*);
            ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:70:13: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:73:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__string_get_length(String*);
^
```
include/qir/DDsimQir.h:73:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_length', which is a reserved identifier
```
long int __quantum__rt__string_get_length(String*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:73:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:77:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_update_reference_count', which is a reserved identifier
```
void __quantum__rt__string_update_reference_count(String*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:77:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:77:60: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__string_update_reference_count(String*, long int);
                                                           ^
```
include/qir/DDsimQir.h:80:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_concatenate', which is a reserved identifier
```
String* __quantum__rt__string_concatenate(String*, String*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:80:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:83:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_equal', which is a reserved identifier
```
Bool __quantum__rt__string_equal(String*, String*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:83:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:86:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__int_to_string', which is a reserved identifier
```
String* __quantum__rt__int_to_string(Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:86:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__int_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:89:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__double_to_string', which is a reserved identifier
```
String* __quantum__rt__double_to_string(Double);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:89:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__double_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:92:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bool_to_string', which is a reserved identifier
```
String* __quantum__rt__bool_to_string(Bool);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:92:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bool_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:95:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_to_string', which is a reserved identifier
```
String* __quantum__rt__result_to_string(Result*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:95:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:98:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__pauli_to_string', which is a reserved identifier
```
String* __quantum__rt__pauli_to_string(Pauli);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:98:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__pauli_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:101:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_to_string', which is a reserved identifier
```
String* __quantum__rt__qubit_to_string(Qubit*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:101:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:104:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__range_to_string', which is a reserved identifier
```
String* __quantum__rt__range_to_string(Range);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:104:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__range_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:107:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_to_string', which is a reserved identifier
```
String* __quantum__rt__bigint_to_string(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:107:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:113:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_i64', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_i64(Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:113:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_i64'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:117:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_array', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_array(long int, char*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:117:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_array'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:117:44: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
BigInt* __quantum__rt__bigint_create_array(long int, char*);
                                           ^
```
include/qir/DDsimQir.h:120:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_data', which is a reserved identifier
```
char* __quantum__rt__bigint_get_data(BigInt*);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:120:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:123:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__bigint_get_length(BigInt*);
^
```
include/qir/DDsimQir.h:123:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_length', which is a reserved identifier
```
long int __quantum__rt__bigint_get_length(BigInt*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:123:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:127:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_update_reference_count', which is a reserved identifier
```
void __quantum__rt__bigint_update_reference_count(BigInt*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:127:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:127:60: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__bigint_update_reference_count(BigInt*, long int);
                                                           ^
```
include/qir/DDsimQir.h:130:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_negate', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_negate(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:130:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_negate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:133:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_add', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_add(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:133:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_add'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:136:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_subtract', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_subtract(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:136:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_subtract'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:139:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_multiply', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_multiply(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:139:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_multiply'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:142:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_divide', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_divide(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:142:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_divide'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:145:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_modulus', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_modulus(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:145:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_modulus'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:148:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_power', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_power(BigInt*, long int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:148:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_power'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:148:46: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
BigInt* __quantum__rt__bigint_power(BigInt*, long int);
                                             ^
```
include/qir/DDsimQir.h:151:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitand', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitand(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:151:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitand'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:154:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitor(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:154:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitor'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:157:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitxor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitxor(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:157:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitxor'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:160:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitnot', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitnot(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:160:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitnot'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:163:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftleft', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftleft(BigInt*, Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:163:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftleft'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:166:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftright', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftright(BigInt*, Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:166:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftright'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:169:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_equal', which is a reserved identifier
```
Bool __quantum__rt__bigint_equal(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:169:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:172:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:172:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:175:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater_eq', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater_eq(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:175:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater_eq'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:180:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Tuple;
^~~~~~~~~~~~~~~~~~
using Tuple = void
```
include/qir/DDsimQir.h:183:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_create', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_create(Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:183:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:186:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_copy', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_copy(Tuple*, Bool force);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:186:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:190:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_reference_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_reference_count(Tuple*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:190:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:190:58: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__tuple_update_reference_count(Tuple*, long int);
                                                         ^
```
include/qir/DDsimQir.h:193:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_alias_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_alias_count(Tuple*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:193:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:193:54: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__tuple_update_alias_count(Tuple*, long int);
                                                     ^
```
include/qir/DDsimQir.h:198:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Array;
^~~~~~~~~~~~~~~~~~
using Array = void
```
include/qir/DDsimQir.h:202:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_create_1d', which is a reserved identifier
```
Array* __quantum__rt__array_create_1d(long int, Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:202:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:202:39: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
Array* __quantum__rt__array_create_1d(long int, Int);
                                      ^
```
include/qir/DDsimQir.h:205:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_copy', which is a reserved identifier
```
Array* __quantum__rt__array_copy(Array*, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:205:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:208:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_concatenate', which is a reserved identifier
```
Array* __quantum__rt__array_concatenate(Array*, Array*);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:208:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:213:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_slice_1d', which is a reserved identifier
```
Array* __quantum__rt__array_slice_1d(Array*, Range, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:213:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:217:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size_1d', which is a reserved identifier
```
Int __quantum__rt__array_get_size_1d(Array*);
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:217:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:220:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr_1d', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr_1d(Array*, Int);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:220:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:224:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_reference_count', which is a reserved identifier
```
void __quantum__rt__array_update_reference_count(Array*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:224:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:224:58: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__array_update_reference_count(Array*, long int);
                                                         ^
```
include/qir/DDsimQir.h:227:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_alias_count', which is a reserved identifier
```
void __quantum__rt__array_update_alias_count(Array*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:227:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:227:54: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__array_update_alias_count(Array*, long int);
                                                     ^
```
include/qir/DDsimQir.h:233:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_create', which is a reserved identifier
```
Array* __quantum__rt__array_create(long int, long int, Int*);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:233:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:233:36: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
Array* __quantum__rt__array_create(long int, long int, Int*);
                                   ^
```
include/qir/DDsimQir.h:233:46: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
Array* __quantum__rt__array_create(long int, long int, Int*);
                                             ^
```
include/qir/DDsimQir.h:236:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__array_get_dim(Array*);
^
```
include/qir/DDsimQir.h:236:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_dim', which is a reserved identifier
```
long int __quantum__rt__array_get_dim(Array*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:236:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_dim'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:240:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size', which is a reserved identifier
```
Int __quantum__rt__array_get_size(Array*, long int);
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:240:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:240:43: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
Int __quantum__rt__array_get_size(Array*, long int);
                                          ^
```
include/qir/DDsimQir.h:244:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr(Array*, Int*);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:244:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:251:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_slice', which is a reserved identifier
```
Array* __quantum__rt__array_slice(Array*, long int, Range, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:251:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:251:43: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
Array* __quantum__rt__array_slice(Array*, long int, Range, Bool);
                                          ^
```
include/qir/DDsimQir.h:258:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_project', which is a reserved identifier
```
Array* __quantum__rt__array_project(Array*, long int, Int, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:258:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_project'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:258:45: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
Array* __quantum__rt__array_project(Array*, long int, Int, Bool);
                                            ^
```
include/qir/DDsimQir.h:263:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Callable;
^~~~~~~~~~~~~~~~~~~~~
using Callable = void
```
include/qir/DDsimQir.h:267:11: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_create', which is a reserved identifier
```
Callable* __quantum__rt__callable_create(void (*f[4])(Tuple*, Tuple*, Tuple*), void (*m[2])(Tuple*, Tuple*, Tuple*), Tuple*);
          ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:267:11: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:271:11: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_copy', which is a reserved identifier
```
Callable* __quantum__rt__callable_copy(Callable*, Bool);
          ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:271:11: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:274:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_invoke', which is a reserved identifier
```
void __quantum__rt__callable_invoke(Callable*, Tuple*, Tuple*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:274:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_invoke'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:277:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_make_adjoint', which is a reserved identifier
```
void __quantum__rt__callable_make_adjoint(Callable*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:277:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_make_adjoint'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:280:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_make_controlled', which is a reserved identifier
```
void __quantum__rt__callable_make_controlled(Callable*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:280:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_make_controlled'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:284:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_update_reference_count', which is a reserved identifier
```
void __quantum__rt__callable_update_reference_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:284:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:284:64: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__callable_update_reference_count(Callable*, long int);
                                                               ^
```
include/qir/DDsimQir.h:287:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_update_alias_count', which is a reserved identifier
```
void __quantum__rt__callable_update_alias_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:287:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:287:60: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__callable_update_alias_count(Callable*, long int);
                                                           ^
```
include/qir/DDsimQir.h:291:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__capture_update_reference_count', which is a reserved identifier
```
void __quantum__rt__capture_update_reference_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:291:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__capture_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:291:63: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__capture_update_reference_count(Callable*, long int);
                                                              ^
```
include/qir/DDsimQir.h:295:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__capture_update_alias_count', which is a reserved identifier
```
void __quantum__rt__capture_update_alias_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:295:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__capture_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:295:59: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__capture_update_alias_count(Callable*, long int);
                                                          ^
```
include/qir/DDsimQir.h:301:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__message', which is a reserved identifier
```
void __quantum__rt__message(String* msg);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:301:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__message'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:304:1: warning: [clang-diagnostic-c11-extensions]

'_Noreturn' is a C11 extension
```
_Noreturn void __quantum__rt__fail(String* msg);
^
```
include/qir/DDsimQir.h:304:16: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__fail', which is a reserved identifier
```
_Noreturn void __quantum__rt__fail(String* msg);
               ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:304:16: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__fail'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:310:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_allocate', which is a reserved identifier
```
Qubit* __quantum__rt__qubit_allocate();
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:310:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_allocate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:313:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_allocate_array', which is a reserved identifier
```
Array* __quantum__rt__qubit_allocate_array(Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:313:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_allocate_array'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:316:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_release', which is a reserved identifier
```
void __quantum__rt__qubit_release(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:316:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_release'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:320:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_release_array', which is a reserved identifier
```
void __quantum__rt__qubit_release_array(Array*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:320:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_release_array'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:326:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__x__body', which is a reserved identifier
```
void __quantum__qis__x__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:326:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__x__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:327:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__y__body', which is a reserved identifier
```
void __quantum__qis__y__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:327:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__y__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:328:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__z__body', which is a reserved identifier
```
void __quantum__qis__z__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:328:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__z__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:329:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__h__body', which is a reserved identifier
```
void __quantum__qis__h__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:329:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__h__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:330:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__sqrtx__body', which is a reserved identifier
```
void __quantum__qis__sqrtx__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:330:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__sqrtx__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:331:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__sqrtxdg__body', which is a reserved identifier
```
void __quantum__qis__sqrtxdg__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:331:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__sqrtxdg__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:332:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__s__body', which is a reserved identifier
```
void __quantum__qis__s__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:332:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__s__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:333:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__sdg__body', which is a reserved identifier
```
void __quantum__qis__sdg__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:333:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__sdg__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:334:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__t__body', which is a reserved identifier
```
void __quantum__qis__t__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:334:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__t__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:335:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__tdg__body', which is a reserved identifier
```
void __quantum__qis__tdg__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:335:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__tdg__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:336:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__rx__body', which is a reserved identifier
```
void __quantum__qis__rx__body(Double, Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:336:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__rx__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:337:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__ry__body', which is a reserved identifier
```
void __quantum__qis__ry__body(Double, Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:337:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__ry__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:338:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__rz__body', which is a reserved identifier
```
void __quantum__qis__rz__body(Double, Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:338:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__rz__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:339:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__cx__body', which is a reserved identifier
```
void __quantum__qis__cx__body(Qubit*, Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:339:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__cx__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:340:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__cnot__body', which is a reserved identifier
```
void __quantum__qis__cnot__body(Qubit*, Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:340:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__cnot__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:341:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__cz__body', which is a reserved identifier
```
void __quantum__qis__cz__body(Qubit*, Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:341:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__cz__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:342:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__ccx__body', which is a reserved identifier
```
void __quantum__qis__ccx__body(Qubit*, Qubit*, Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:342:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__ccx__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:343:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__ccz__body', which is a reserved identifier
```
void __quantum__qis__ccz__body(Qubit*, Qubit*, Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:343:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__ccz__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:344:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__mz__body', which is a reserved identifier
```
void __quantum__qis__mz__body(Qubit*, Result*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:344:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__mz__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:345:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__m__body', which is a reserved identifier
```
void __quantum__qis__m__body(Qubit*, Result*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:345:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__m__body'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:346:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__qis__reset__body', which is a reserved identifier
```
void __quantum__qis__reset__body(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:346:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__qis__reset__body'
```
note: this fix will not be applied because it overlaps with another fix
```
scripts/qir/examples/BellPair.c

scripts/qir/examples/BellPair.c:1:10: error: [clang-diagnostic-error]

'DDsimQir.h' file not found
```
#include "DDsimQir.h"
         ^~~~~~~~~~~~
```
scripts/qir/examples/BellPair.c:3:10: warning: [modernize-deprecated-headers]

inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead
```
#include <stdlib.h>
         ^~~~~~~~~~
         <cstdlib>
```
scripts/qir/examples/BellPair.cpp

scripts/qir/examples/BellPair.cpp:1:10: error: [clang-diagnostic-error]

'DDsimQir.h' file not found
```
#include "DDsimQir.h"
         ^~~~~~~~~~~~
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc

scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:11:10: error: [clang-diagnostic-error]

'QirContext.hpp' file not found
```
#include "QirContext.hpp"
         ^~~~~~~~~~~~~~~~
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:19:48: warning: [bugprone-reserved-identifier]

declaration uses identifier 'Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop', which is a reserved identifier
```
extern "C" double                              Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop(double, double, double, long);
                                               ^
note: this fix will not be applied because it overlaps with another fix
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:19:48: warning: [readability-identifier-naming]

invalid case style for function 'Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop'
```
note: this fix will not be applied because it overlaps with another fix
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:19:153: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
extern "C" double                              Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop(double, double, double, long);
                                                                                                                                                        ^
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:20:48: warning: [readability-identifier-naming]

invalid case style for function 'GetDMSim'
```
extern "C" Microsoft::Quantum::IRuntimeDriver* GetDMSim();
                                               ^~~~~~~~
                                               getDmSim
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:21:48: warning: [bugprone-reserved-identifier]

declaration uses identifier 'Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE', which is a reserved identifier
```
extern "C" void                                Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE(double, double, double, long);
                                               ^
note: this fix will not be applied because it overlaps with another fix
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:21:48: warning: [readability-identifier-naming]

invalid case style for function 'Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE'
```
note: this fix will not be applied because it overlaps with another fix
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:21:144: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
extern "C" void                                Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE(double, double, double, long);
                                                                                                                                               ^
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:23:6: warning: [readability-identifier-naming]

invalid case style for function 'get_energy'
```
void get_energy(double theta1, double theta2, double theta3, long nsamples) {
     ^~~~~~~~~~
     getEnergy
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:23:62: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void get_energy(double theta1, double theta2, double theta3, long nsamples) {
                                                             ^
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:24:5: warning: [misc-const-correctness]

variable 'i_gpu' of type 'int' can be declared 'const'
```
    int i_gpu = 0;
    ^
        const 
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:24:9: warning: [readability-identifier-naming]

invalid case style for local variable 'i_gpu'
```
    int i_gpu = 0;
        ^~~~~
        iGpu
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:26:5: warning: [misc-const-correctness]

variable 'jwTermEnergy' of type 'double' can be declared 'const'
```
    double jwTermEnergy = Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop(theta1, theta2, theta3, nsamples);
    ^
           const 
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:38:5: warning: [misc-const-correctness]

variable 'theta1' of type 'double' can be declared 'const'
```
    double                              theta1 = atof(argv[1]);
    ^
                                        const 
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:38:55: warning: [cppcoreguidelines-pro-bounds-pointer-arithmetic]

do not use pointer arithmetic
```
    double                              theta1 = atof(argv[1]);
                                                      ^
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:39:5: warning: [misc-const-correctness]

variable 'theta2' of type 'double' can be declared 'const'
```
    double                              theta2 = atof(argv[2]);
    ^
                                        const 
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:39:55: warning: [cppcoreguidelines-pro-bounds-pointer-arithmetic]

do not use pointer arithmetic
```
    double                              theta2 = atof(argv[2]);
                                                      ^
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:40:5: warning: [misc-const-correctness]

variable 'theta3' of type 'double' can be declared 'const'
```
    double                              theta3 = atof(argv[3]);
    ^
                                        const 
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:40:55: warning: [cppcoreguidelines-pro-bounds-pointer-arithmetic]

do not use pointer arithmetic
```
    double                              theta3 = atof(argv[3]);
                                                      ^
```
scripts/qir/examples/VariationalQuantumEigensolver_driver.cc:41:41: warning: [cppcoreguidelines-init-variables]

variable 'dmsim' is not initialized
```
    Microsoft::Quantum::IRuntimeDriver* dmsim  = GetDMSim();
                                        ^
                                              = nullptr
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc

scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:1:19: warning: [bugprone-reserved-identifier]

declaration uses identifier 'Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop', which is a reserved identifier
```
extern "C" double Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop(double, double, double, long);
                  ^
note: this fix will not be applied because it overlaps with another fix
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:1:19: warning: [readability-identifier-naming]

invalid case style for function 'Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop'
```
note: this fix will not be applied because it overlaps with another fix
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:1:124: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
extern "C" double Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop(double, double, double, long);
                                                                                                                           ^
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:2:19: warning: [bugprone-reserved-identifier]

declaration uses identifier 'Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE', which is a reserved identifier
```
extern "C" void   Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE(double, double, double, long);
                  ^
note: this fix will not be applied because it overlaps with another fix
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:2:19: warning: [readability-identifier-naming]

invalid case style for function 'Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE'
```
note: this fix will not be applied because it overlaps with another fix
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:2:115: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
extern "C" void   Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE(double, double, double, long);
                                                                                                                  ^
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:4:6: warning: [readability-identifier-naming]

invalid case style for function 'get_energy'
```
void get_energy(double theta1, double theta2, double theta3, long nsamples) {
     ^~~~~~~~~~
     getEnergy
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:4:62: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void get_energy(double theta1, double theta2, double theta3, long nsamples) {
                                                             ^
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:5:5: warning: [misc-const-correctness]

variable 'jwTermEnergy' of type 'double' can be declared 'const'
```
    double jwTermEnergy = Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop(theta1, theta2, theta3, nsamples);
    ^
           const 
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:5:12: warning: [clang-analyzer-deadcode.DeadStores]

Value stored to 'jwTermEnergy' during its initialization is never read
```
    double jwTermEnergy = Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop(theta1, theta2, theta3, nsamples);
           ^~~~~~~~~~~~   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/runner/work/mqt-ddsim/mqt-ddsim/scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:5:12: note: Value stored to 'jwTermEnergy' during its initialization is never read
    double jwTermEnergy = Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop(theta1, theta2, theta3, nsamples);
           ^~~~~~~~~~~~   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:5:12: warning: [clang-diagnostic-unused-variable]

unused variable 'jwTermEnergy'
```
    double jwTermEnergy = Microsoft__Quantum__Samples__Chemistry__SimpleVQE__GetEnergyHydrogenVQE__Interop(theta1, theta2, theta3, nsamples);
           ^
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:8:14: warning: [clang-diagnostic-unused-parameter]

unused parameter 'argc'
```
int main(int argc, char* argv[]) {
             ^
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:8:14: warning: [misc-unused-parameters]

parameter 'argc' is unused
```
int main(int argc, char* argv[]) {
             ^~~~
              /*argc*/
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:8:26: warning: [clang-diagnostic-unused-parameter]

unused parameter 'argv'
```
int main(int argc, char* argv[]) {
                         ^
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:8:26: warning: [misc-unused-parameters]

parameter 'argv' is unused
```
int main(int argc, char* argv[]) {
                         ^~~~
                          /*argv*/
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:9:5: warning: [misc-const-correctness]

variable 'theta1' of type 'double' can be declared 'const'
```
    double theta1 = 0.1;
    ^
           const 
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:10:5: warning: [misc-const-correctness]

variable 'theta2' of type 'double' can be declared 'const'
```
    double theta2 = 0.2;
    ^
           const 
```
scripts/qir/examples/VariationalQuantumEigensolver_wrapper.cc:11:5: warning: [misc-const-correctness]

variable 'theta3' of type 'double' can be declared 'const'
```
    double theta3 = 0.3;
    ^
           const 
```
src/qir/DDsimQir.cpp

src/qir/DDsimQir.cpp:1:10: error: [clang-diagnostic-error]

'DDsimQir.h' file not found
```
#include "DDsimQir.h"
         ^~~~~~~~~~~~
```
src/qir/DDsimQir.cpp:6:10: warning: [modernize-deprecated-headers]

inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead
```
#include <stdio.h>
         ^~~~~~~~~
         <cstdio>
```
src/qir/DDsimQir.cpp:7:10: warning: [modernize-deprecated-headers]

inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead
```
#include <stdlib.h>
         ^~~~~~~~~~
         <cstdlib>
```
src/qir/DDsimQir.cpp:16:25: warning: [cppcoreguidelines-avoid-non-const-global-variables]

variable 'qc' is non-const and globally accessible, consider making it const
```
qc::QuantumComputation* qc = NULL;
                        ^
```
src/qir/DDsimQir.cpp:16:25: warning: [cppcoreguidelines-avoid-non-const-global-variables]

variable 'qc' provides global access to a non-const object; consider making the pointed-to data 'const'

src/qir/DDsimQir.cpp:18:6: warning: [readability-identifier-naming]

invalid case style for function 'create_quantum_computation'
```
void create_quantum_computation(unsigned long long int n) {
     ^~~~~~~~~~~~~~~~~~~~~~~~~~
     createQuantumComputation
```
src/qir/DDsimQir.cpp:18:33: warning: [google-runtime-int]

consider replacing 'unsigned long long' with 'uint64'
```
void create_quantum_computation(unsigned long long int n) {
                                ^
```
src/qir/DDsimQir.cpp:22:6: warning: [readability-identifier-naming]

invalid case style for function 'delete_quantum_computation'
```
void delete_quantum_computation() {
     ^~~~~~~~~~~~~~~~~~~~~~~~~~
     deleteQuantumComputation
```
src/qir/DDsimQir.cpp:28:25: warning: [readability-identifier-naming]

invalid case style for function 'get_quantum_computation_handle'
```
qc::QuantumComputation* get_quantum_computation_handle() {
                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                        getQuantumComputationHandle
```
src/qir/DDsimQir.cpp:42:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_zero', which is a reserved identifier
```
Result* __quantum__rt__result_get_zero() {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:42:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_zero'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:43:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:43:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:44:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:47:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_one', which is a reserved identifier
```
Result* __quantum__rt__result_get_one() {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:47:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_one'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:48:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:48:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:49:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:52:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_equal', which is a reserved identifier
```
Bool __quantum__rt__result_equal(Result*, Result*) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:52:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:52:41: warning: [readability-named-parameter]

all parameters should be named in a function
```
Bool __quantum__rt__result_equal(Result*, Result*) {
                                        ^
                                         /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:53:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:53:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:57:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_update_reference_count', which is a reserved identifier
```
void __quantum__rt__result_update_reference_count(Result*, long int) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:57:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:57:58: warning: [readability-named-parameter]

all parameters should be named in a function
```
void __quantum__rt__result_update_reference_count(Result*, long int) {
                                                         ^
                                                          /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:57:60: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__result_update_reference_count(Result*, long int) {
                                                           ^
```
src/qir/DDsimQir.cpp:58:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:58:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:62:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_create', which is a reserved identifier
```
String* __quantum__rt__string_create(const char*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:62:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_create'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:62:49: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__string_create(const char*) {
                                                ^
                                                 /*unused*/
```
src/qir/DDsimQir.cpp:63:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:63:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:64:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:67:13: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_data', which is a reserved identifier
```
const char* __quantum__rt__string_get_data(String*) {
            ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:67:13: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:67:51: warning: [readability-named-parameter]

all parameters should be named in a function
```
const char* __quantum__rt__string_get_data(String*) {
                                                  ^
                                                   /*unused*/
```
src/qir/DDsimQir.cpp:68:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:68:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:69:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:72:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__string_get_length(String*) {
^
```
src/qir/DDsimQir.cpp:72:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_length', which is a reserved identifier
```
long int __quantum__rt__string_get_length(String*) {
         ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:72:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:72:50: warning: [readability-named-parameter]

all parameters should be named in a function
```
long int __quantum__rt__string_get_length(String*) {
                                                 ^
                                                  /*unused*/
```
src/qir/DDsimQir.cpp:73:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:73:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:77:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_update_reference_count', which is a reserved identifier
```
void __quantum__rt__string_update_reference_count(String*, long int) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:77:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:77:58: warning: [readability-named-parameter]

all parameters should be named in a function
```
void __quantum__rt__string_update_reference_count(String*, long int) {
                                                         ^
                                                          /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:77:60: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__string_update_reference_count(String*, long int) {
                                                           ^
```
src/qir/DDsimQir.cpp:78:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:78:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:81:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_concatenate', which is a reserved identifier
```
String* __quantum__rt__string_concatenate(String*, String*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:81:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:81:50: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__string_concatenate(String*, String*) {
                                                 ^
                                                  /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:82:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:82:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:83:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:86:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_equal', which is a reserved identifier
```
Bool __quantum__rt__string_equal(String*, String*) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:86:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:86:41: warning: [readability-named-parameter]

all parameters should be named in a function
```
Bool __quantum__rt__string_equal(String*, String*) {
                                        ^
                                         /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:87:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:87:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:91:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__int_to_string', which is a reserved identifier
```
String* __quantum__rt__int_to_string(Int) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:91:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__int_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:91:41: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__int_to_string(Int) {
                                        ^
                                         /*unused*/
```
src/qir/DDsimQir.cpp:92:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:92:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:93:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:96:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__double_to_string', which is a reserved identifier
```
String* __quantum__rt__double_to_string(Double) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:96:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__double_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:96:47: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__double_to_string(Double) {
                                              ^
                                               /*unused*/
```
src/qir/DDsimQir.cpp:97:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:97:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:98:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:101:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bool_to_string', which is a reserved identifier
```
String* __quantum__rt__bool_to_string(Bool) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:101:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bool_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:101:43: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__bool_to_string(Bool) {
                                          ^
                                           /*unused*/
```
src/qir/DDsimQir.cpp:102:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:102:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:103:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:106:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_to_string', which is a reserved identifier
```
String* __quantum__rt__result_to_string(Result*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:106:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:106:48: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__result_to_string(Result*) {
                                               ^
                                                /*unused*/
```
src/qir/DDsimQir.cpp:107:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:107:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:108:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:111:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__pauli_to_string', which is a reserved identifier
```
String* __quantum__rt__pauli_to_string(Pauli) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:111:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__pauli_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:111:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__pauli_to_string(Pauli) {
                                            ^
                                             /*unused*/
```
src/qir/DDsimQir.cpp:112:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:112:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:113:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:116:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_to_string', which is a reserved identifier
```
String* __quantum__rt__qubit_to_string(Qubit*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:116:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:116:46: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__qubit_to_string(Qubit*) {
                                             ^
                                              /*unused*/
```
src/qir/DDsimQir.cpp:117:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:117:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:118:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:121:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__range_to_string', which is a reserved identifier
```
String* __quantum__rt__range_to_string(Range) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:121:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__range_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:121:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__range_to_string(Range) {
                                            ^
                                             /*unused*/
```
src/qir/DDsimQir.cpp:122:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:122:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:123:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:126:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_to_string', which is a reserved identifier
```
String* __quantum__rt__bigint_to_string(BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:126:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:126:48: warning: [readability-named-parameter]

all parameters should be named in a function
```
String* __quantum__rt__bigint_to_string(BigInt*) {
                                               ^
                                                /*unused*/
```
src/qir/DDsimQir.cpp:127:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:127:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:128:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:132:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_i64', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_i64(Int) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:132:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_i64'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:132:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_create_i64(Int) {
                                            ^
                                             /*unused*/
```
src/qir/DDsimQir.cpp:133:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:133:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:134:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:137:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_array', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_array(long int, char*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:137:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_array'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:137:52: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_create_array(long int, char*) {
                                                   ^
                                                    /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:138:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:138:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:139:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:142:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_data', which is a reserved identifier
```
char* __quantum__rt__bigint_get_data(BigInt*) {
      ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:142:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:142:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
char* __quantum__rt__bigint_get_data(BigInt*) {
                                            ^
                                             /*unused*/
```
src/qir/DDsimQir.cpp:143:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:143:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:144:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:147:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__bigint_get_length(BigInt*) {
^
```
src/qir/DDsimQir.cpp:147:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_length', which is a reserved identifier
```
long int __quantum__rt__bigint_get_length(BigInt*) {
         ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:147:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:147:50: warning: [readability-named-parameter]

all parameters should be named in a function
```
long int __quantum__rt__bigint_get_length(BigInt*) {
                                                 ^
                                                  /*unused*/
```
src/qir/DDsimQir.cpp:148:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:148:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:152:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_update_reference_count', which is a reserved identifier
```
void __quantum__rt__bigint_update_reference_count(BigInt*, long int) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:152:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:152:58: warning: [readability-named-parameter]

all parameters should be named in a function
```
void __quantum__rt__bigint_update_reference_count(BigInt*, long int) {
                                                         ^
                                                          /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:152:60: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__bigint_update_reference_count(BigInt*, long int) {
                                                           ^
```
src/qir/DDsimQir.cpp:153:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:153:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:156:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_negate', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_negate(BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:156:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_negate'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:156:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_negate(BigInt*) {
                                            ^
                                             /*unused*/
```
src/qir/DDsimQir.cpp:157:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:157:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:158:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:161:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_add', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_add(BigInt*, BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:161:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_add'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:161:42: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_add(BigInt*, BigInt*) {
                                         ^
                                          /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:162:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:162:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:163:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:166:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_subtract', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_subtract(BigInt*, BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:166:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_subtract'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:166:47: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_subtract(BigInt*, BigInt*) {
                                              ^
                                               /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:167:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:167:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:168:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:171:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_multiply', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_multiply(BigInt*, BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:171:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_multiply'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:171:47: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_multiply(BigInt*, BigInt*) {
                                              ^
                                               /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:172:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:172:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:173:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:176:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_divide', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_divide(BigInt*, BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:176:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_divide'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:176:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_divide(BigInt*, BigInt*) {
                                            ^
                                             /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:177:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:177:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:178:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:181:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_modulus', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_modulus(BigInt*, BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:181:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_modulus'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:181:46: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_modulus(BigInt*, BigInt*) {
                                             ^
                                              /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:182:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:182:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:183:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:186:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_power', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_power(BigInt*, long int) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:186:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_power'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:186:44: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_power(BigInt*, long int) {
                                           ^
                                            /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:187:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:187:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:188:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:191:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitand', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitand(BigInt*, BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:191:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitand'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:191:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_bitand(BigInt*, BigInt*) {
                                            ^
                                             /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:192:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:192:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:193:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:196:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitor(BigInt*, BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:196:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitor'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:196:44: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_bitor(BigInt*, BigInt*) {
                                           ^
                                            /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:197:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:197:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:198:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:201:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitxor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitxor(BigInt*, BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:201:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitxor'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:201:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_bitxor(BigInt*, BigInt*) {
                                            ^
                                             /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:202:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:202:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:203:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:206:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitnot', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitnot(BigInt*) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:206:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitnot'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:206:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_bitnot(BigInt*) {
                                            ^
                                             /*unused*/
```
src/qir/DDsimQir.cpp:207:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:207:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:208:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:211:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftleft', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftleft(BigInt*, Int) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:211:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftleft'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:211:48: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_shiftleft(BigInt*, Int) {
                                               ^
                                                /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:212:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:212:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:213:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:216:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftright', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftright(BigInt*, Int) {
        ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:216:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftright'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:216:49: warning: [readability-named-parameter]

all parameters should be named in a function
```
BigInt* __quantum__rt__bigint_shiftright(BigInt*, Int) {
                                                ^
                                                 /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:217:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:217:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:218:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:221:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_equal', which is a reserved identifier
```
Bool __quantum__rt__bigint_equal(BigInt*, BigInt*) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:221:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:221:41: warning: [readability-named-parameter]

all parameters should be named in a function
```
Bool __quantum__rt__bigint_equal(BigInt*, BigInt*) {
                                        ^
                                         /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:222:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:222:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:226:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater(BigInt*, BigInt*) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:226:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:226:43: warning: [readability-named-parameter]

all parameters should be named in a function
```
Bool __quantum__rt__bigint_greater(BigInt*, BigInt*) {
                                          ^
                                           /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:227:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:227:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:231:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater_eq', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater_eq(BigInt*, BigInt*) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:231:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater_eq'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:231:46: warning: [readability-named-parameter]

all parameters should be named in a function
```
Bool __quantum__rt__bigint_greater_eq(BigInt*, BigInt*) {
                                             ^
                                              /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:232:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:232:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:237:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_create', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_create(Int) {
       ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:237:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_create'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:237:39: warning: [readability-named-parameter]

all parameters should be named in a function
```
Tuple* __quantum__rt__tuple_create(Int) {
                                      ^
                                       /*unused*/
```
src/qir/DDsimQir.cpp:238:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:238:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:239:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:242:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_copy', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_copy(Tuple*, Bool force) {
       ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:242:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:242:40: warning: [readability-named-parameter]

all parameters should be named in a function
```
Tuple* __quantum__rt__tuple_copy(Tuple*, Bool force) {
                                       ^
                                        /*unused*/
```
src/qir/DDsimQir.cpp:243:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:243:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:244:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:247:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_reference_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_reference_count(Tuple*, long int) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:247:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:247:56: warning: [readability-named-parameter]

all parameters should be named in a function
```
void __quantum__rt__tuple_update_reference_count(Tuple*, long int) {
                                                       ^
                                                        /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:247:58: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__tuple_update_reference_count(Tuple*, long int) {
                                                         ^
```
src/qir/DDsimQir.cpp:248:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:248:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:251:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_alias_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_alias_count(Tuple*, long int) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:251:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:251:52: warning: [readability-named-parameter]

all parameters should be named in a function
```
void __quantum__rt__tuple_update_alias_count(Tuple*, long int) {
                                                   ^
                                                    /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:251:54: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__tuple_update_alias_count(Tuple*, long int) {
                                                     ^
```
src/qir/DDsimQir.cpp:252:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:252:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:256:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_create_1d', which is a reserved identifier
```
Array* __quantum__rt__array_create_1d(long int size, Int n) {
       ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:256:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:257:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:257:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:258:12: warning: [cppcoreguidelines-init-variables]

variable 'a' is not initialized
```
    Array* a = malloc(size * n);
           ^
             = nullptr
```
src/qir/DDsimQir.cpp:259:14: warning: [cppcoreguidelines-init-variables]

variable 'i' is not initialized
```
    for (Int i = 0; i < n; i++) {
             ^
               = 0
```
src/qir/DDsimQir.cpp:265:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_copy', which is a reserved identifier
```
Array* __quantum__rt__array_copy(Array*, Bool) {
       ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:265:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:265:40: warning: [readability-named-parameter]

all parameters should be named in a function
```
Array* __quantum__rt__array_copy(Array*, Bool) {
                                       ^
                                        /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:266:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:266:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:267:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:270:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_concatenate', which is a reserved identifier
```
Array* __quantum__rt__array_concatenate(Array*, Array*) {
       ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:270:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:270:47: warning: [readability-named-parameter]

all parameters should be named in a function
```
Array* __quantum__rt__array_concatenate(Array*, Array*) {
                                              ^
                                               /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:271:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:271:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:272:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:275:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_slice_1d', which is a reserved identifier
```
Array* __quantum__rt__array_slice_1d(Array*, Range, Bool) {
       ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:275:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:275:44: warning: [readability-named-parameter]

all parameters should be named in a function
```
Array* __quantum__rt__array_slice_1d(Array*, Range, Bool) {
                                           ^
                                            /*unused*/  /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:276:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:276:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:277:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:280:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size_1d', which is a reserved identifier
```
Int __quantum__rt__array_get_size_1d(Array*) {
    ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:280:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:280:44: warning: [readability-named-parameter]

all parameters should be named in a function
```
Int __quantum__rt__array_get_size_1d(Array*) {
                                           ^
                                            /*unused*/
```
src/qir/DDsimQir.cpp:281:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:281:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:285:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr_1d', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr_1d(Array*, Int) {
      ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:285:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:285:53: warning: [readability-named-parameter]

all parameters should be named in a function
```
char* __quantum__rt__array_get_element_ptr_1d(Array*, Int) {
                                                    ^
                                                     /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:286:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:286:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:287:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:290:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_reference_count', which is a reserved identifier
```
void __quantum__rt__array_update_reference_count(Array*, long int) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:290:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:290:56: warning: [readability-named-parameter]

all parameters should be named in a function
```
void __quantum__rt__array_update_reference_count(Array*, long int) {
                                                       ^
                                                        /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:290:58: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__array_update_reference_count(Array*, long int) {
                                                         ^
```
src/qir/DDsimQir.cpp:291:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:291:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:294:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_alias_count', which is a reserved identifier
```
void __quantum__rt__array_update_alias_count(Array*, long int) {
     ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:294:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:294:52: warning: [readability-named-parameter]

all parameters should be named in a function
```
void __quantum__rt__array_update_alias_count(Array*, long int) {
                                                   ^
                                                    /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:294:54: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
void __quantum__rt__array_update_alias_count(Array*, long int) {
                                                     ^
```
src/qir/DDsimQir.cpp:295:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:295:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:298:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_create', which is a reserved identifier
```
Array* __quantum__rt__array_create(long int, long int, Int*) {
       ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:298:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:298:44: warning: [readability-named-parameter]

all parameters should be named in a function
```
Array* __quantum__rt__array_create(long int, long int, Int*) {
                                           ^
                                            /*unused*/  /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:299:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:299:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:300:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:303:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__array_get_dim(Array*) {
^
```
src/qir/DDsimQir.cpp:303:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_dim', which is a reserved identifier
```
long int __quantum__rt__array_get_dim(Array*) {
         ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:303:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_dim'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:303:45: warning: [readability-named-parameter]

all parameters should be named in a function
```
long int __quantum__rt__array_get_dim(Array*) {
                                            ^
                                             /*unused*/
```
src/qir/DDsimQir.cpp:304:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:304:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:308:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size', which is a reserved identifier
```
Int __quantum__rt__array_get_size(Array*, long int) {
    ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:308:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:308:41: warning: [readability-named-parameter]

all parameters should be named in a function
```
Int __quantum__rt__array_get_size(Array*, long int) {
                                        ^
                                         /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:309:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:309:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:313:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr(Array*, Int*) {
      ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:313:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:313:50: warning: [readability-named-parameter]

all parameters should be named in a function
```
char* __quantum__rt__array_get_element_ptr(Array*, Int*) {
                                                 ^
                                                  /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:314:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:314:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:315:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:318:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_slice', which is a reserved identifier
```
Array* __quantum__rt__array_slice(Array*, long int, Range, Bool) {
       ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:318:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:318:41: warning: [readability-named-parameter]

all parameters should be named in a function
```
Array* __quantum__rt__array_slice(Array*, long int, Range, Bool) {
                                        ^
                                         /*unused*/  /*unused*/  /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:319:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:319:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:320:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:323:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_project', which is a reserved identifier
```
Array* __quantum__rt__array_project(Array*, long int, Int, Bool) {
       ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:323:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_project'
```
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:323:43: warning: [readability-named-parameter]

all parameters should be named in a function
```
Array* __quantum__rt__array_project(Array*, long int, Int, Bool) {
                                          ^
                                           /*unused*/  /*unused*/  /*unused*/  /*unused*/
```
src/qir/DDsimQir.cpp:324:5: warning: [cppcoreguidelines-pro-type-vararg]

do not call c-style vararg functions
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    ^
```
src/qir/DDsimQir.cpp:324:37: warning: [cppcoreguidelines-pro-bounds-array-to-pointer-decay]

do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead
```
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
                                    ^
```
src/qir/DDsimQir.cpp:325:12: warning: [modernize-use-nullptr]

use nullptr
```
    return NULL;
           ^~~~
           nullptr
```
src/qir/DDsimQir.cpp:329:11: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_create', which is a reserved identifier
```
Callable* __quantum__rt__callable_create(void (*f[4])(Tuple*, Tuple*, Tuple*), void (*c[2])(Tuple*, Tuple*, Tuple*), Tuple*) {
          ^
note: this fix will not be applied because it overlaps with another fix
```
src/qir/DDsimQir.cpp:329:11: warning: [cppcoreguidelines-avoid-non-const-global-variables]

variable '__quantum__rt__callable_create' is non-const and globally accessible, consider making it const

src/qir/DDsimQir.cpp:329:11: warning: [cppcoreguidelines-avoid-non-const-global-variables]

variable '__quantum__rt__callable_create' provides global access to a non-const object; consider making the pointed-to data 'const'

src/qir/DDsimQir.cpp:329:11: warning: [readability-identifier-naming]

invalid case style for variable '__quantum__rt__callable_create'
```
note: this fix will not be applied because it overlaps with another fix
```

Have any feedback or feature suggestions? Share it here.

Jan 18 '24 21:01 github-actions[bot]

Codecov Report

All modified and coverable lines are covered by tests :white_check_mark:

Additional details and impacted files

@@          Coverage Diff          @@
##            main    #335   +/-   ##
=====================================
  Coverage   92.7%   92.8%           
=====================================
  Files         35      35           
  Lines       2704    2703    -1     
  Branches     349     348    -1     
=====================================
  Hits        2509    2509           
+ Misses       195     194    -1

Flag	Coverage Δ
cpp	`94.6% <ø> (+<0.1%)`	:arrow_up:
python	`87.9% <ø> (ø)`

see 2 files with indirect coverage changes

Jan 18 '24 21:01 codecov[bot]

Cpp-Linter Report :warning:

Some files did not pass the configured checks!

clang-tidy reports: 623 concern(s)

include/qir/DDsimQir.h:6:10: warning: [modernize-deprecated-headers]

including 'stdbool.h' has no effect in C++; consider removing it
```
#include <stdbool.h>
~~~~~~~~~^~~~~~~~~~~
```

include/qir/DDsimQir.h:21:1: warning: [modernize-use-using]

typedef signed long long int Int;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Int = long long

include/qir/DDsimQir.h:21:9: warning: [google-runtime-int]

consider replacing 'long long' with 'int64'
```
typedef signed long long int Int;
        ^
```

include/qir/DDsimQir.h:22:1: warning: [modernize-use-using]

typedef double               Double;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Double = double

include/qir/DDsimQir.h:23:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef bool                 Bool;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
using Bool = bool
```
include/qir/DDsimQir.h:24:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef enum {
^~~~~~~~~~~~~~
```
include/qir/DDsimQir.h:25:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_I'
```
    PauliId_I = 0,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:26:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_X'
```
    PauliId_X = 1,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:27:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_Z'
```
    PauliId_Z = 2,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:28:5: warning: [readability-identifier-naming]

invalid case style for enum constant 'PauliId_Y'
```
    PauliId_Y = 3,
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:30:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef struct {
^~~~~~~~~~~~~~~~
```
include/qir/DDsimQir.h:37:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void BigInt;
^~~~~~~~~~~~~~~~~~~
using BigInt = void
```
include/qir/DDsimQir.h:42:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Result;
^~~~~~~~~~~~~~~~~~~
using Result = void
```
include/qir/DDsimQir.h:45:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_zero', which is a reserved identifier
```
Result* __quantum__rt__result_get_zero();
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:45:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_zero'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:48:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_get_one', which is a reserved identifier
```
Result* __quantum__rt__result_get_one();
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:48:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_get_one'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:51:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_equal', which is a reserved identifier
```
Bool __quantum__rt__result_equal(Result*, Result*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:51:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:55:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_update_reference_count', which is a reserved identifier
```
void __quantum__rt__result_update_reference_count(Result*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:55:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:55:60: warning: [google-runtime-int]

void __quantum__rt__result_update_reference_count(Result*, long int);
                                                           ^

include/qir/DDsimQir.h:59:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Qubit;
^~~~~~~~~~~~~~~~~~
using Qubit = void
```
include/qir/DDsimQir.h:64:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef char String;
^~~~~~~~~~~~~~~~~~~
using String = char
```
include/qir/DDsimQir.h:67:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_create', which is a reserved identifier
```
String* __quantum__rt__string_create(const char*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:67:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:70:13: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_data', which is a reserved identifier
```
const char* __quantum__rt__string_get_data(String*);
            ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:70:13: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:73:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__string_get_length(String*);
^
```
include/qir/DDsimQir.h:73:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_get_length', which is a reserved identifier
```
long int __quantum__rt__string_get_length(String*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:73:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:77:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_update_reference_count', which is a reserved identifier
```
void __quantum__rt__string_update_reference_count(String*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:77:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:77:60: warning: [google-runtime-int]

void __quantum__rt__string_update_reference_count(String*, long int);
                                                           ^

include/qir/DDsimQir.h:80:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_concatenate', which is a reserved identifier
```
String* __quantum__rt__string_concatenate(String*, String*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:80:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:83:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__string_equal', which is a reserved identifier
```
Bool __quantum__rt__string_equal(String*, String*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:83:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__string_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:86:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__int_to_string', which is a reserved identifier
```
String* __quantum__rt__int_to_string(Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:86:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__int_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:89:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__double_to_string', which is a reserved identifier
```
String* __quantum__rt__double_to_string(Double);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:89:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__double_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:92:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bool_to_string', which is a reserved identifier
```
String* __quantum__rt__bool_to_string(Bool);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:92:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bool_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:95:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__result_to_string', which is a reserved identifier
```
String* __quantum__rt__result_to_string(Result*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:95:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__result_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:98:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__pauli_to_string', which is a reserved identifier
```
String* __quantum__rt__pauli_to_string(Pauli);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:98:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__pauli_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:101:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_to_string', which is a reserved identifier
```
String* __quantum__rt__qubit_to_string(Qubit*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:101:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:104:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__range_to_string', which is a reserved identifier
```
String* __quantum__rt__range_to_string(Range);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:104:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__range_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:107:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_to_string', which is a reserved identifier
```
String* __quantum__rt__bigint_to_string(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:107:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_to_string'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:113:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_i64', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_i64(Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:113:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_i64'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:117:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_create_array', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_create_array(long int, char*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:117:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_create_array'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:117:44: warning: [google-runtime-int]

BigInt* __quantum__rt__bigint_create_array(long int, char*);
                                           ^

include/qir/DDsimQir.h:120:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_data', which is a reserved identifier
```
char* __quantum__rt__bigint_get_data(BigInt*);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:120:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_data'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:123:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__bigint_get_length(BigInt*);
^
```
include/qir/DDsimQir.h:123:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_get_length', which is a reserved identifier
```
long int __quantum__rt__bigint_get_length(BigInt*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:123:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_get_length'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:127:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_update_reference_count', which is a reserved identifier
```
void __quantum__rt__bigint_update_reference_count(BigInt*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:127:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:127:60: warning: [google-runtime-int]

void __quantum__rt__bigint_update_reference_count(BigInt*, long int);
                                                           ^

include/qir/DDsimQir.h:130:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_negate', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_negate(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:130:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_negate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:133:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_add', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_add(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:133:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_add'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:136:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_subtract', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_subtract(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:136:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_subtract'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:139:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_multiply', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_multiply(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:139:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_multiply'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:142:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_divide', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_divide(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:142:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_divide'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:145:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_modulus', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_modulus(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:145:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_modulus'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:148:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_power', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_power(BigInt*, long int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:148:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_power'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:148:46: warning: [google-runtime-int]

BigInt* __quantum__rt__bigint_power(BigInt*, long int);
                                             ^

include/qir/DDsimQir.h:151:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitand', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitand(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:151:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitand'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:154:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitor(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:154:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitor'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:157:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitxor', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitxor(BigInt*, BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:157:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitxor'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:160:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_bitnot', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_bitnot(BigInt*);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:160:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_bitnot'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:163:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftleft', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftleft(BigInt*, Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:163:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftleft'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:166:9: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_shiftright', which is a reserved identifier
```
BigInt* __quantum__rt__bigint_shiftright(BigInt*, Int);
        ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:166:9: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_shiftright'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:169:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_equal', which is a reserved identifier
```
Bool __quantum__rt__bigint_equal(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:169:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_equal'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:172:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:172:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:175:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__bigint_greater_eq', which is a reserved identifier
```
Bool __quantum__rt__bigint_greater_eq(BigInt*, BigInt*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:175:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__bigint_greater_eq'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:180:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Tuple;
^~~~~~~~~~~~~~~~~~
using Tuple = void
```
include/qir/DDsimQir.h:183:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_create', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_create(Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:183:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:186:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_copy', which is a reserved identifier
```
Tuple* __quantum__rt__tuple_copy(Tuple*, Bool force);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:186:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:190:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_reference_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_reference_count(Tuple*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:190:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:190:58: warning: [google-runtime-int]

void __quantum__rt__tuple_update_reference_count(Tuple*, long int);
                                                         ^

include/qir/DDsimQir.h:193:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__tuple_update_alias_count', which is a reserved identifier
```
void __quantum__rt__tuple_update_alias_count(Tuple*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:193:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__tuple_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:193:54: warning: [google-runtime-int]

void __quantum__rt__tuple_update_alias_count(Tuple*, long int);
                                                     ^

include/qir/DDsimQir.h:198:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Array;
^~~~~~~~~~~~~~~~~~
using Array = void
```
include/qir/DDsimQir.h:202:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_create_1d', which is a reserved identifier
```
Array* __quantum__rt__array_create_1d(long int, Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:202:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:202:39: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
Array* __quantum__rt__array_create_1d(long int, Int);
                                      ^
```
include/qir/DDsimQir.h:205:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_copy', which is a reserved identifier
```
Array* __quantum__rt__array_copy(Array*, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:205:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:208:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_concatenate', which is a reserved identifier
```
Array* __quantum__rt__array_concatenate(Array*, Array*);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:208:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_concatenate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:213:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_slice_1d', which is a reserved identifier
```
Array* __quantum__rt__array_slice_1d(Array*, Range, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:213:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:217:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size_1d', which is a reserved identifier
```
Int __quantum__rt__array_get_size_1d(Array*);
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:217:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:220:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr_1d', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr_1d(Array*, Int);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:220:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr_1d'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:224:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_reference_count', which is a reserved identifier
```
void __quantum__rt__array_update_reference_count(Array*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:224:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:224:58: warning: [google-runtime-int]

void __quantum__rt__array_update_reference_count(Array*, long int);
                                                         ^

include/qir/DDsimQir.h:227:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_update_alias_count', which is a reserved identifier
```
void __quantum__rt__array_update_alias_count(Array*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:227:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:227:54: warning: [google-runtime-int]

void __quantum__rt__array_update_alias_count(Array*, long int);
                                                     ^

include/qir/DDsimQir.h:233:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_create', which is a reserved identifier
```
Array* __quantum__rt__array_create(long int, long int, Int*);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:233:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_create'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:233:36: warning: [google-runtime-int]

Array* __quantum__rt__array_create(long int, long int, Int*);
                                   ^

include/qir/DDsimQir.h:233:46: warning: [google-runtime-int]

Array* __quantum__rt__array_create(long int, long int, Int*);
                                             ^

include/qir/DDsimQir.h:236:1: warning: [google-runtime-int]

consider replacing 'long' with 'int64'
```
long int __quantum__rt__array_get_dim(Array*);
^
```
include/qir/DDsimQir.h:236:10: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_dim', which is a reserved identifier
```
long int __quantum__rt__array_get_dim(Array*);
         ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:236:10: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_dim'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:240:5: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_size', which is a reserved identifier
```
Int __quantum__rt__array_get_size(Array*, long int);
    ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:240:5: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_size'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:240:43: warning: [google-runtime-int]

Int __quantum__rt__array_get_size(Array*, long int);
                                          ^

include/qir/DDsimQir.h:244:7: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_get_element_ptr', which is a reserved identifier
```
char* __quantum__rt__array_get_element_ptr(Array*, Int*);
      ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:244:7: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_get_element_ptr'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:251:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_slice', which is a reserved identifier
```
Array* __quantum__rt__array_slice(Array*, long int, Range, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:251:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_slice'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:251:43: warning: [google-runtime-int]

Array* __quantum__rt__array_slice(Array*, long int, Range, Bool);
                                          ^

include/qir/DDsimQir.h:258:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__array_project', which is a reserved identifier
```
Array* __quantum__rt__array_project(Array*, long int, Int, Bool);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:258:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__array_project'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:258:45: warning: [google-runtime-int]

Array* __quantum__rt__array_project(Array*, long int, Int, Bool);
                                            ^

include/qir/DDsimQir.h:263:1: warning: [modernize-use-using]

use 'using' instead of 'typedef'
```
typedef void Callable;
^~~~~~~~~~~~~~~~~~~~~
using Callable = void
```

include/qir/DDsimQir.h:267:11: warning: [bugprone-reserved-identifier]

Callable* __quantum__rt__callable_create(void (*f[4])(Tuple*, Tuple*, Tuple*), void (*m[2])(Tuple*, Tuple*, Tuple*), Tuple*);
          ^
note: this fix will not be applied because it overlaps with another fix

include/qir/DDsimQir.h:267:11: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_create'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:271:11: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_copy', which is a reserved identifier
```
Callable* __quantum__rt__callable_copy(Callable*, Bool);
          ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:271:11: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_copy'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:274:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_invoke', which is a reserved identifier
```
void __quantum__rt__callable_invoke(Callable*, Tuple*, Tuple*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:274:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_invoke'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:277:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_make_adjoint', which is a reserved identifier
```
void __quantum__rt__callable_make_adjoint(Callable*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:277:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_make_adjoint'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:280:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_make_controlled', which is a reserved identifier
```
void __quantum__rt__callable_make_controlled(Callable*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:280:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_make_controlled'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:284:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_update_reference_count', which is a reserved identifier
```
void __quantum__rt__callable_update_reference_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:284:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:284:64: warning: [google-runtime-int]

void __quantum__rt__callable_update_reference_count(Callable*, long int);
                                                               ^

include/qir/DDsimQir.h:287:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__callable_update_alias_count', which is a reserved identifier
```
void __quantum__rt__callable_update_alias_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:287:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__callable_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:287:60: warning: [google-runtime-int]

void __quantum__rt__callable_update_alias_count(Callable*, long int);
                                                           ^

include/qir/DDsimQir.h:291:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__capture_update_reference_count', which is a reserved identifier
```
void __quantum__rt__capture_update_reference_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:291:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__capture_update_reference_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:291:63: warning: [google-runtime-int]

void __quantum__rt__capture_update_reference_count(Callable*, long int);
                                                              ^

include/qir/DDsimQir.h:295:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__capture_update_alias_count', which is a reserved identifier
```
void __quantum__rt__capture_update_alias_count(Callable*, long int);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:295:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__capture_update_alias_count'
```
note: this fix will not be applied because it overlaps with another fix
```

include/qir/DDsimQir.h:295:59: warning: [google-runtime-int]

void __quantum__rt__capture_update_alias_count(Callable*, long int);
                                                          ^

include/qir/DDsimQir.h:301:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__message', which is a reserved identifier
```
void __quantum__rt__message(String* msg);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:301:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__message'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:304:16: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__fail', which is a reserved identifier
```
_Noreturn void __quantum__rt__fail(String* msg);
               ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:304:16: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__fail'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:310:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_allocate', which is a reserved identifier
```
Qubit* __quantum__rt__qubit_allocate();
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:310:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_allocate'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:313:8: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_allocate_array', which is a reserved identifier
```
Array* __quantum__rt__qubit_allocate_array(Int);
       ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:313:8: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_allocate_array'
```
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:316:6: warning: [bugprone-reserved-identifier]

declaration uses identifier '__quantum__rt__qubit_release', which is a reserved identifier
```
void __quantum__rt__qubit_release(Qubit*);
     ^
note: this fix will not be applied because it overlaps with another fix
```
include/qir/DDsimQir.h:316:6: warning: [readability-identifier-naming]

invalid case style for function '__quantum__rt__qubit_release'
```
note: this fix will not be applied because it overlaps with another fix
```

Have any feedback or feature suggestions? Share it here.

May 23 '24 07:05 github-actions[bot]

mqt-ddsim mqt-ddsim copied to clipboard

:sparkles: Enable QIR support

Description

Checklist:

Cpp-Linter Report :warning:

Codecov Report

Cpp-Linter Report :warning:

mqt-ddsim
mqt-ddsim copied to clipboard