Imports

Types

BASS_BFX_ROTATE {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fRate*: cfloat ## ``` ## rotation rate/speed in Hz (A negative rate can be used for reverse direction) ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s (supported only even number of channels) ## ```

  Deprecated effects in 2.4.10 version:
        
        ------------------------------------
        
        BASS_FX_BFX_ECHO		-> use BASS_FX_BFX_ECHO4
        
        BASS_FX_BFX_ECHO2		-> use BASS_FX_BFX_ECHO4
        
        BASS_FX_BFX_ECHO3		-> use BASS_FX_BFX_ECHO4
        
        BASS_FX_BFX_REVERB		-> use BASS_FX_BFX_FREEVERB
        
        BASS_FX_BFX_FLANGER		-> use BASS_FX_BFX_CHORUS
        
        BASS_FX_BFX_COMPRESSOR	-> use BASS_FX_BFX_COMPRESSOR2
        
        BASS_FX_BFX_APF			-> use BASS_FX_BFX_BQF with BASS_BFX_BQF_ALLPASS filter
        
        BASS_FX_BFX_LPF			-> use 2x BASS_FX_BFX_BQF with BASS_BFX_BQF_LOWPASS filter and appropriate fQ values
     
     
     Rotate

BASS_BFX_ECHO {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fLevel*: cfloat ## ``` ## [0....1....n] linear ## ``` lDelay*: cint ## ``` ## [1200..30000] ## ```

  Echo (deprecated)

BASS_BFX_FLANGER {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fWetDry*: cfloat ## ``` ## [0....1....n] linear ## ``` fSpeed*: cfloat ## ``` ## [0......0.09] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Flanger (deprecated)

BASS_BFX_VOLUME {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s or 0 for global volume control ## ``` fVolume*: cfloat ## ``` ## [0....1....n] linear ## ```

  Volume

BASS_BFX_PEAKEQ {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object lBand*: cint ## ``` ## [0...............n] more bands means more memory & cpu usage ## ``` fBandwidth*: cfloat ## ``` ## [0.1...........<10] in octaves - fQ is not in use (Bandwidth has a priority over fQ) ## ``` fQ*: cfloat ## ``` ## [0...............1] the EE kinda definition (linear) (if Bandwidth is not in use) ## ``` fCenter*: cfloat ## ``` ## [1Hz..<info.freq/2] in Hz ## ``` fGain*: cfloat ## ``` ## [-15dB...0...+15dB] in dB (can be above/below these limits) ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Peaking Equalizer

BASS_BFX_REVERB {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fLevel*: cfloat ## ``` ## [0....1....n] linear ## ``` lDelay*: cint ## ``` ## [1200..10000] ## ```

  Reverb (deprecated)

BASS_BFX_LPF {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fResonance*: cfloat ## ``` ## [0.01...........10] ## ``` fCutOffFreq*: cfloat ## ``` ## [1Hz...info.freq/2] cutoff frequency ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Low Pass Filter (deprecated)

BASS_BFX_MIX {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object lChannel*: ptr cint ## ``` ## an array of channels to mix using BASS_BFX_CHANxxx flag/s (lChannel[0] is left channel...) ## ```

  Swap, remap and mix

BASS_BFX_DAMP {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fTarget*: cfloat ## ``` ## target volume level [0<......1] linear ## ``` fQuiet*: cfloat ## ``` ## quiet volume level [0.......1] linear ## ``` fRate*: cfloat ## ``` ## amp adjustment rate [0.......1] linear ## ``` fGain*: cfloat ## ``` ## amplification level [0...1...n] linear ## ``` fDelay*: cfloat ## ``` ## delay in seconds before increasing level [0.......n] linear ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Dynamic Amplification

BASS_BFX_AUTOWAH {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fDryMix*: cfloat ## ``` ## dry (unaffected) signal mix [-2......2] ## ``` fWetMix*: cfloat ## ``` ## wet (affected) signal mix [-2......2] ## ``` fFeedback*: cfloat ## ``` ## output signal to feed back into input [-1......1] ## ``` fRate*: cfloat ## ``` ## rate of sweep in cycles per second [0<....<10] ## ``` fRange*: cfloat ## ``` ## sweep range in octaves [0<....<10] ## ``` fFreq*: cfloat ## ``` ## base frequency of sweep Hz [0<...1000] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Auto Wah

BASS_BFX_ECHO2 {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fDryMix*: cfloat ## ``` ## dry (unaffected) signal mix [-2......2] ## ``` fWetMix*: cfloat ## ``` ## wet (affected) signal mix [-2......2] ## ``` fFeedback*: cfloat ## ``` ## output signal to feed back into input [-1......1] ## ``` fDelay*: cfloat ## ``` ## delay sec [0<......n] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Echo 2 (deprecated)

BASS_BFX_PHASER {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fDryMix*: cfloat ## ``` ## dry (unaffected) signal mix [-2......2] ## ``` fWetMix*: cfloat ## ``` ## wet (affected) signal mix [-2......2] ## ``` fFeedback*: cfloat ## ``` ## output signal to feed back into input [-1......1] ## ``` fRate*: cfloat ## ``` ## rate of sweep in cycles per second [0<....<10] ## ``` fRange*: cfloat ## ``` ## sweep range in octaves [0<....<10] ## ``` fFreq*: cfloat ## ``` ## base frequency of sweep [0<...1000] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Phaser

BASS_BFX_ECHO3 {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fDryMix*: cfloat ## ``` ## dry (unaffected) signal mix [-2......2] ## ``` fWetMix*: cfloat ## ``` ## wet (affected) signal mix [-2......2] ## ``` fDelay*: cfloat ## ``` ## delay sec [0<......n] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Echo 3 (deprecated)

BASS_BFX_CHORUS {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fDryMix*: cfloat ## ``` ## dry (unaffected) signal mix [-2......2] ## ``` fWetMix*: cfloat ## ``` ## wet (affected) signal mix [-2......2] ## ``` fFeedback*: cfloat ## ``` ## output signal to feed back into input [-1......1] ## ``` fMinSweep*: cfloat ## ``` ## minimal delay ms [0<...6000] ## ``` fMaxSweep*: cfloat ## ``` ## maximum delay ms [0<...6000] ## ``` fRate*: cfloat ## ``` ## rate ms/s [0<...1000] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Chorus/Flanger

BASS_BFX_APF {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fGain*: cfloat ## ``` ## reverberation time [-1=<..<=1] ## ``` fDelay*: cfloat ## ``` ## delay sec [0<....<=n] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  All Pass Filter (deprecated)

BASS_BFX_COMPRESSOR {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fThreshold*: cfloat ## ``` ## compressor threshold [0<=...<=1] ## ``` fAttacktime*: cfloat ## ``` ## attack time ms [0<.<=1000] ## ``` fReleasetime*: cfloat ## ``` ## release time ms [0<.<=5000] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Compressor (deprecated)

BASS_BFX_DISTORTION {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fDrive*: cfloat ## ``` ## distortion drive [0<=...<=5] ## ``` fDryMix*: cfloat ## ``` ## dry (unaffected) signal mix [-5<=..<=5] ## ``` fWetMix*: cfloat ## ``` ## wet (affected) signal mix [-5<=..<=5] ## ``` fFeedback*: cfloat ## ``` ## output signal to feed back into input [-1<=..<=1] ## ``` fVolume*: cfloat ## ``` ## distortion volume [0=<...<=2] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Distortion

BASS_BFX_COMPRESSOR2 {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fGain*: cfloat ## ``` ## output gain of signal after compression [-60....60] in dB ## ``` fThreshold*: cfloat ## ``` ## point at which compression begins [-60.....0] in dB ## ``` fRatio*: cfloat ## ``` ## compression ratio [1.......n] ## ``` fAttack*: cfloat ## ``` ## attack time in ms [0.01.1000] ## ``` fRelease*: cfloat ## ``` ## release time in ms [0.01.5000] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Compressor 2

BASS_BFX_VOLUME_ENV {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ``` lNodeCount*: cint ## ``` ## number of nodes ## ``` pNodes*: ptr BASS_BFX_ENV_NODE ## ``` ## the nodes ## ``` bFollow*: BOOL ## ``` ## follow source position ## ```

  Volume envelope

BASS_BFX_ENV_NODE {...}{.bycopy, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h", importc: "struct BASS_BFX_ENV_NODE".} = object pos*: cdouble ## ``` ## node position in seconds (1st envelope node must be at position 0) ## ``` val*: cfloat ## ``` ## node value ## ```

BASS_BFX_BQF {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object lFilter*: cint ## ``` ## BASS_BFX_BQF_xxx filter types ## ``` fCenter*: cfloat ## ``` ## [1Hz..<info.freq/2] Cutoff (central) frequency in Hz ## ``` fGain*: cfloat ## ``` ## [-15dB...0...+15dB] Used only for PEAKINGEQ and Shelving filters in dB (can be above/below these limits) ## ``` fBandwidth*: cfloat ## ``` ## [0.1...........<10] Bandwidth in octaves (fQ is not in use (fBandwidth has a priority over fQ)) ## (between -3 dB frequencies for BANDPASS and NOTCH or between midpoint ## (fGgain/2) gain frequencies for PEAKINGEQ) ## ``` fQ*: cfloat ## ``` ## [0.1.............1] The EE kinda definition (linear) (if fBandwidth is not in use) ## ``` fS*: cfloat ## ``` ## [0.1.............1] A "shelf slope" parameter (linear) (used only with Shelving filters) ## when fS = 1, the shelf slope is as steep as you can get it and remain monotonically ## increasing or decreasing gain with frequency. ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

BASS_BFX_ECHO4 {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fDryMix*: cfloat ## ``` ## dry (unaffected) signal mix [-2.......2] ## ``` fWetMix*: cfloat ## ``` ## wet (affected) signal mix [-2.......2] ## ``` fFeedback*: cfloat ## ``` ## output signal to feed back into input [-1.......1] ## ``` fDelay*: cfloat ## ``` ## delay sec [0<.......n] ## ``` bStereo*: BOOL ## ``` ## echo adjoining channels to each other [TRUE/FALSE] ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Echo 4

BASS_BFX_PITCHSHIFT {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fPitchShift*: cfloat ## ``` ## A factor value which is between 0.5 (one octave down) and 2 (one octave up) (1 won't change the pitch) [1 default] ## (fSemitones is not in use, fPitchShift has a priority over fSemitones) ## ``` fSemitones*: cfloat ## ``` ## Semitones (0 won't change the pitch) [0 default] ## ``` lFFTsize*: clong ## ``` ## Defines the FFT frame size used for the processing. Typical values are 1024, 2048 and 4096 [2048 default] ## It may be any value <= 8192 but it MUST be a power of 2 ## ``` lOsamp*: clong ## ``` ## Is the STFT oversampling factor which also determines the overlap between adjacent STFT frames [8 default] ## It should at least be 4 for moderate scaling ratios. A value of 32 is recommended for best quality (better quality = higher CPU usage) ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

  Pitch shift (not available on mobile)

BASS_BFX_FREEVERB {...}{.bycopy, importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = object fDryMix*: cfloat ## ``` ## dry (unaffected) signal mix [0........1], def. 0 ## ``` fWetMix*: cfloat ## ``` ## wet (affected) signal mix [0........3], def. 1.0f ## ``` fRoomSize*: cfloat ## ``` ## room size [0........1], def. 0.5f ## ``` fDamp*: cfloat ## ``` ## damping [0........1], def. 0.5f ## ``` fWidth*: cfloat ## ``` ## stereo width [0........1], def. 1 ## ``` lMode*: DWORD ## ``` ## 0 or BASS_BFX_FREEVERB_MODE_FREEZE, def. 0 (no freeze) ## ``` lChannel*: cint ## ``` ## BASS_BFX_CHANxxx flag/s ## ```

BPMPROC {...}{.importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = proc ( chan: DWORD; bpm: cfloat; user: pointer) {...}{.cdecl.}

BPMPROGRESSPROC {...}{.importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = proc ( chan: DWORD; percent: cfloat; user: pointer) {...}{.cdecl.}

BPMPROCESSPROC {...}{.importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = BPMPROGRESSPROC

  back-compatibility

BPMBEATPROC {...}{.importc, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".} = proc ( chan: DWORD; beatpos: cdouble; user: pointer) {...}{.cdecl.}

Consts

bassfxStd = false

bassfxGit = false

bassfxDL = true

bassfxConan = false

bassfxJBB = false

bassfxStatic = false

bassfxSetVer = "24"

bassfxPath = "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h"

bassfxLPath = "/home/genotrance/Dropbox/Private/github/wrappers/nimbass/build/htmldocs/libbass_fx.so"

bassfxLDeps = []

BASS_CTYPE_STREAM_TEMPO = 0x0001F200

BASS_CTYPE_STREAM_REVERSE = 0x0001F201

BASS_FX_FREESOURCE = 0x00010000

BASS_BFX_CHANALL = -1

BASS_BFX_CHANNONE = 0

BASS_BFX_CHAN1 = 1

BASS_BFX_CHAN2 = 2

BASS_BFX_CHAN3 = 4

BASS_BFX_CHAN4 = 8

BASS_BFX_CHAN5 = 16

BASS_BFX_CHAN6 = 32

BASS_BFX_CHAN7 = 64

BASS_BFX_CHAN8 = 128

BASS_FX_BFX_ROTATE = 65536'i32

  A channels volume ping-pong	/ multi channel

BASS_FX_BFX_ECHO = 65537'i32

  Echo							/ 2 channels max	(deprecated)

BASS_FX_BFX_FLANGER = 65538'i32

  Flanger						/ multi channel		(deprecated)

BASS_FX_BFX_VOLUME = 65539'i32

  Volume						/ multi channel

BASS_FX_BFX_PEAKEQ = 65540'i32

  Peaking Equalizer			/ multi channel

BASS_FX_BFX_REVERB = 65541'i32

  Reverb						/ 2 channels max	(deprecated)

BASS_FX_BFX_LPF = 65542'i32

  Low Pass Filter 24dB			/ multi channel		(deprecated)

BASS_FX_BFX_MIX = 65543'i32

  Swap, remap and mix channels	/ multi channel

BASS_FX_BFX_DAMP = 65544'i32

  Dynamic Amplification		/ multi channel

BASS_FX_BFX_AUTOWAH = 65545'i32

  Auto Wah						/ multi channel

BASS_FX_BFX_ECHO2 = 65546'i32

  Echo 2						/ multi channel		(deprecated)

BASS_FX_BFX_PHASER = 65547'i32

  Phaser						/ multi channel

BASS_FX_BFX_ECHO3 = 65548'i32

  Echo 3						/ multi channel		(deprecated)

BASS_FX_BFX_CHORUS = 65549'i32

  Chorus/Flanger				/ multi channel

BASS_FX_BFX_APF = 65550'i32

  All Pass Filter				/ multi channel		(deprecated)

BASS_FX_BFX_COMPRESSOR = 65551'i32

  Compressor					/ multi channel		(deprecated)

BASS_FX_BFX_DISTORTION = 65552'i32

  Distortion					/ multi channel

BASS_FX_BFX_COMPRESSOR2 = 65553'i32

  Compressor 2					/ multi channel

BASS_FX_BFX_VOLUME_ENV = 65554'i32

  Volume envelope				/ multi channel

BASS_FX_BFX_BQF = 65555'i32

  BiQuad filters				/ multi channel

BASS_FX_BFX_ECHO4 = 65556'i32

  Echo	4						/ multi channel

BASS_FX_BFX_PITCHSHIFT = 65557'i32

  Pitch shift using FFT		/ multi channel		(not available on mobile)

BASS_FX_BFX_FREEVERB = 65558'i32

  Reverb using "Freeverb" algo	/ multi channel

BASS_BFX_BQF_LOWPASS = 0'i32

BASS_BFX_BQF_HIGHPASS = 1'i32

BASS_BFX_BQF_BANDPASS = 2'i32

  constant 0 dB peak gain

BASS_BFX_BQF_BANDPASS_Q = 3'i32

  constant skirt gain, peak gain = Q

BASS_BFX_BQF_NOTCH = 4'i32

  constant skirt gain, peak gain = Q

BASS_BFX_BQF_ALLPASS = 5'i32

BASS_BFX_BQF_PEAKINGEQ = 6'i32

BASS_BFX_BQF_LOWSHELF = 7'i32

BASS_BFX_BQF_HIGHSHELF = 8'i32

BASS_BFX_FREEVERB_MODE_FREEZE = 1

BASS_ATTRIB_TEMPO = 65536'i32

BASS_ATTRIB_TEMPO_PITCH = 65537'i32

BASS_ATTRIB_TEMPO_FREQ = 65538'i32

BASS_ATTRIB_TEMPO_OPTION_USE_AA_FILTER = 65552'i32

  TRUE (default) / FALSE (default for multi-channel on mobile devices for lower CPU usage)

BASS_ATTRIB_TEMPO_OPTION_AA_FILTER_LENGTH = 65553'i32

  32 default (8 .. 128 taps)

BASS_ATTRIB_TEMPO_OPTION_USE_QUICKALGO = 65554'i32

  TRUE (default on mobile devices for lower CPU usage) / FALSE (default)

BASS_ATTRIB_TEMPO_OPTION_SEQUENCE_MS = 65555'i32

  82 default, 0 = automatic

BASS_ATTRIB_TEMPO_OPTION_SEEKWINDOW_MS = 65556'i32

  28 default, 0 = automatic

BASS_ATTRIB_TEMPO_OPTION_OVERLAP_MS = 65557'i32

  8  default

BASS_ATTRIB_TEMPO_OPTION_PREVENT_CLICK = 65558'i32

  TRUE / FALSE (default)

BASS_FX_TEMPO_ALGO_LINEAR = 0x00000200

BASS_FX_TEMPO_ALGO_CUBIC = 0x00000400

BASS_FX_TEMPO_ALGO_SHANNON = 0x00000800

BASS_ATTRIB_REVERSE_DIR = 0x00011000

BASS_FX_RVS_REVERSE = -1

BASS_FX_RVS_FORWARD = 1

BASS_FX_BPM_BKGRND = 1

BASS_FX_BPM_MULT2 = 2

BASS_FX_BPM_TRAN_X2 = 0'i32

  multiply the original BPM value by 2 (may be called only once & will change the original BPM as well!)

BASS_FX_BPM_TRAN_2FREQ = 1'i32

  BPM value to Frequency

BASS_FX_BPM_TRAN_FREQ2 = 2'i32

  Frequency to BPM value

BASS_FX_BPM_TRAN_2PERCENT = 3'i32

  BPM value to Percents

BASS_FX_BPM_TRAN_PERCENT2 = 4'i32

  Percents to BPM value

Procs

proc `+`(x`gensym20590157: Enum_bass_fxh1; y`gensym20590158: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `+`(x`gensym20590159: cint; y`gensym20590160: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `+`(x`gensym20590161, y`gensym20590162: Enum_bass_fxh1): Enum_bass_fxh1 {...}{.borrow.}

proc `+`(x`gensym20590163: Enum_bass_fxh1; y`gensym20590164: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `+`(x`gensym20590165: int; y`gensym20590166: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20590167: Enum_bass_fxh1; y`gensym20590168: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `-`(x`gensym20590169: cint; y`gensym20590170: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `-`(x`gensym20590171, y`gensym20590172: Enum_bass_fxh1): Enum_bass_fxh1 {...}{.borrow.}

proc `-`(x`gensym20590173: Enum_bass_fxh1; y`gensym20590174: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20590175: int; y`gensym20590176: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20590177: Enum_bass_fxh1; y`gensym20590178: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `*`(x`gensym20590179: cint; y`gensym20590180: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `*`(x`gensym20590181, y`gensym20590182: Enum_bass_fxh1): Enum_bass_fxh1 {...}{.borrow.}

proc `*`(x`gensym20590183: Enum_bass_fxh1; y`gensym20590184: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20590185: int; y`gensym20590186: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20590187: Enum_bass_fxh1; y`gensym20590188: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `div`(x`gensym20590189: cint; y`gensym20590190: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `div`(x`gensym20590191, y`gensym20590192: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `div`(x`gensym20590193: Enum_bass_fxh1; y`gensym20590194: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20590195: int; y`gensym20590196: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20590197: Enum_bass_fxh1; y`gensym20590198: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `mod`(x`gensym20590199: cint; y`gensym20590200: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `mod`(x`gensym20590201, y`gensym20590202: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `mod`(x`gensym20590203: Enum_bass_fxh1; y`gensym20590204: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20590205: int; y`gensym20590206: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20590207: Enum_bass_fxh1; y`gensym20590208: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `shl`(x`gensym20590209: cint; y`gensym20590210: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `shl`(x`gensym20590211, y`gensym20590212: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `shl`(x`gensym20590213: Enum_bass_fxh1; y`gensym20590214: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20590215: int; y`gensym20590216: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20590217: Enum_bass_fxh1; y`gensym20590218: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `shr`(x`gensym20590219: cint; y`gensym20590220: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `shr`(x`gensym20590221, y`gensym20590222: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `shr`(x`gensym20590223: Enum_bass_fxh1; y`gensym20590224: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20590225: int; y`gensym20590226: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20590227: Enum_bass_fxh1; y`gensym20590228: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `or`(x`gensym20590229: cint; y`gensym20590230: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `or`(x`gensym20590231, y`gensym20590232: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `or`(x`gensym20590233: Enum_bass_fxh1; y`gensym20590234: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20590235: int; y`gensym20590236: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20590237: Enum_bass_fxh1; y`gensym20590238: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `and`(x`gensym20590239: cint; y`gensym20590240: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `and`(x`gensym20590241, y`gensym20590242: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `and`(x`gensym20590243: Enum_bass_fxh1; y`gensym20590244: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20590245: int; y`gensym20590246: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20590247: Enum_bass_fxh1; y`gensym20590248: cint): Enum_bass_fxh1 {...}{. borrow.}

proc `xor`(x`gensym20590249: cint; y`gensym20590250: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `xor`(x`gensym20590251, y`gensym20590252: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. borrow.}

proc `xor`(x`gensym20590253: Enum_bass_fxh1; y`gensym20590254: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20590255: int; y`gensym20590256: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `<`(x`gensym20590257: Enum_bass_fxh1; y`gensym20590258: cint): bool {...}{.borrow.}

proc `<`(x`gensym20590259: cint; y`gensym20590260: Enum_bass_fxh1): bool {...}{.borrow.}

proc `<`(x`gensym20590261, y`gensym20590262: Enum_bass_fxh1): bool {...}{.borrow.}

proc `<`(x`gensym20590263: Enum_bass_fxh1; y`gensym20590264: int): bool {...}{.raises: [], tags: [].}

proc `<`(x`gensym20590265: int; y`gensym20590266: Enum_bass_fxh1): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20590267: Enum_bass_fxh1; y`gensym20590268: cint): bool {...}{.borrow.}

proc `<=`(x`gensym20590269: cint; y`gensym20590270: Enum_bass_fxh1): bool {...}{.borrow.}

proc `<=`(x`gensym20590271, y`gensym20590272: Enum_bass_fxh1): bool {...}{.borrow.}

proc `<=`(x`gensym20590273: Enum_bass_fxh1; y`gensym20590274: int): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20590275: int; y`gensym20590276: Enum_bass_fxh1): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20590277: Enum_bass_fxh1; y`gensym20590278: cint): bool {...}{.borrow.}

proc `==`(x`gensym20590279: cint; y`gensym20590280: Enum_bass_fxh1): bool {...}{.borrow.}

proc `==`(x`gensym20590281, y`gensym20590282: Enum_bass_fxh1): bool {...}{.borrow.}

proc `==`(x`gensym20590283: Enum_bass_fxh1; y`gensym20590284: int): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20590285: int; y`gensym20590286: Enum_bass_fxh1): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20590287: Enum_bass_fxh1; y`gensym20590288: cint): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20590289: cint; y`gensym20590290: Enum_bass_fxh1): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20590291, y`gensym20590292: Enum_bass_fxh1): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20590293: Enum_bass_fxh1; y`gensym20590294: int): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20590295: int; y`gensym20590296: Enum_bass_fxh1): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20590297: Enum_bass_fxh1; y`gensym20590298: cint): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20590299: cint; y`gensym20590300: Enum_bass_fxh1): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20590301, y`gensym20590302: Enum_bass_fxh1): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20590303: Enum_bass_fxh1; y`gensym20590304: int): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20590305: int; y`gensym20590306: Enum_bass_fxh1): bool {...}{.raises: [], tags: [].}

proc `/`(x`gensym20590307, y`gensym20590308: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20590309: Enum_bass_fxh1; y`gensym20590310: cint): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20590311: cint; y`gensym20590312: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20590313: Enum_bass_fxh1; y`gensym20590314: int): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20590315: int; y`gensym20590316: Enum_bass_fxh1): Enum_bass_fxh1 {...}{. raises: [], tags: [].}

proc `$`(x`gensym20590317: Enum_bass_fxh1): string {...}{.borrow.}

proc `not`(x`gensym20590318: Enum_bass_fxh1): Enum_bass_fxh1 {...}{.borrow.}

proc `+`(x`gensym20595959: Enum_bass_fxh2; y`gensym20595960: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `+`(x`gensym20595961: cint; y`gensym20595962: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `+`(x`gensym20595963, y`gensym20595964: Enum_bass_fxh2): Enum_bass_fxh2 {...}{.borrow.}

proc `+`(x`gensym20595965: Enum_bass_fxh2; y`gensym20595966: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `+`(x`gensym20595967: int; y`gensym20595968: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20595969: Enum_bass_fxh2; y`gensym20595970: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `-`(x`gensym20595971: cint; y`gensym20595972: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `-`(x`gensym20595973, y`gensym20595974: Enum_bass_fxh2): Enum_bass_fxh2 {...}{.borrow.}

proc `-`(x`gensym20595975: Enum_bass_fxh2; y`gensym20595976: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20595977: int; y`gensym20595978: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20595979: Enum_bass_fxh2; y`gensym20595980: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `*`(x`gensym20595981: cint; y`gensym20595982: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `*`(x`gensym20595983, y`gensym20595984: Enum_bass_fxh2): Enum_bass_fxh2 {...}{.borrow.}

proc `*`(x`gensym20595985: Enum_bass_fxh2; y`gensym20595986: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20595987: int; y`gensym20595988: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20595989: Enum_bass_fxh2; y`gensym20595990: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `div`(x`gensym20595991: cint; y`gensym20595992: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `div`(x`gensym20595993, y`gensym20595994: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `div`(x`gensym20595995: Enum_bass_fxh2; y`gensym20595996: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20595997: int; y`gensym20595998: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20595999: Enum_bass_fxh2; y`gensym20596000: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `mod`(x`gensym20596001: cint; y`gensym20596002: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `mod`(x`gensym20596003, y`gensym20596004: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `mod`(x`gensym20596005: Enum_bass_fxh2; y`gensym20596006: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20596007: int; y`gensym20596008: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20596009: Enum_bass_fxh2; y`gensym20596010: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `shl`(x`gensym20596011: cint; y`gensym20596012: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `shl`(x`gensym20596013, y`gensym20596014: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `shl`(x`gensym20596015: Enum_bass_fxh2; y`gensym20596016: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20596017: int; y`gensym20596018: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20596019: Enum_bass_fxh2; y`gensym20596020: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `shr`(x`gensym20596021: cint; y`gensym20596022: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `shr`(x`gensym20596023, y`gensym20596024: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `shr`(x`gensym20596025: Enum_bass_fxh2; y`gensym20596026: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20596027: int; y`gensym20596028: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20596029: Enum_bass_fxh2; y`gensym20596030: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `or`(x`gensym20596031: cint; y`gensym20596032: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `or`(x`gensym20596033, y`gensym20596034: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `or`(x`gensym20596035: Enum_bass_fxh2; y`gensym20596036: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20596037: int; y`gensym20596038: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20596039: Enum_bass_fxh2; y`gensym20596040: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `and`(x`gensym20596041: cint; y`gensym20596042: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `and`(x`gensym20596043, y`gensym20596044: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `and`(x`gensym20596045: Enum_bass_fxh2; y`gensym20596046: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20596047: int; y`gensym20596048: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20596049: Enum_bass_fxh2; y`gensym20596050: cint): Enum_bass_fxh2 {...}{. borrow.}

proc `xor`(x`gensym20596051: cint; y`gensym20596052: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `xor`(x`gensym20596053, y`gensym20596054: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. borrow.}

proc `xor`(x`gensym20596055: Enum_bass_fxh2; y`gensym20596056: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20596057: int; y`gensym20596058: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `<`(x`gensym20596059: Enum_bass_fxh2; y`gensym20596060: cint): bool {...}{.borrow.}

proc `<`(x`gensym20596061: cint; y`gensym20596062: Enum_bass_fxh2): bool {...}{.borrow.}

proc `<`(x`gensym20596063, y`gensym20596064: Enum_bass_fxh2): bool {...}{.borrow.}

proc `<`(x`gensym20596065: Enum_bass_fxh2; y`gensym20596066: int): bool {...}{.raises: [], tags: [].}

proc `<`(x`gensym20596067: int; y`gensym20596068: Enum_bass_fxh2): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20596069: Enum_bass_fxh2; y`gensym20596070: cint): bool {...}{.borrow.}

proc `<=`(x`gensym20596071: cint; y`gensym20596072: Enum_bass_fxh2): bool {...}{.borrow.}

proc `<=`(x`gensym20596073, y`gensym20596074: Enum_bass_fxh2): bool {...}{.borrow.}

proc `<=`(x`gensym20596075: Enum_bass_fxh2; y`gensym20596076: int): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20596077: int; y`gensym20596078: Enum_bass_fxh2): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20596079: Enum_bass_fxh2; y`gensym20596080: cint): bool {...}{.borrow.}

proc `==`(x`gensym20596081: cint; y`gensym20596082: Enum_bass_fxh2): bool {...}{.borrow.}

proc `==`(x`gensym20596083, y`gensym20596084: Enum_bass_fxh2): bool {...}{.borrow.}

proc `==`(x`gensym20596085: Enum_bass_fxh2; y`gensym20596086: int): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20596087: int; y`gensym20596088: Enum_bass_fxh2): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20596089: Enum_bass_fxh2; y`gensym20596090: cint): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20596091: cint; y`gensym20596092: Enum_bass_fxh2): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20596093, y`gensym20596094: Enum_bass_fxh2): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20596095: Enum_bass_fxh2; y`gensym20596096: int): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20596097: int; y`gensym20596098: Enum_bass_fxh2): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20596099: Enum_bass_fxh2; y`gensym20596100: cint): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20596101: cint; y`gensym20596102: Enum_bass_fxh2): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20596103, y`gensym20596104: Enum_bass_fxh2): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20596105: Enum_bass_fxh2; y`gensym20596106: int): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20596107: int; y`gensym20596108: Enum_bass_fxh2): bool {...}{.raises: [], tags: [].}

proc `/`(x`gensym20596109, y`gensym20596110: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20596111: Enum_bass_fxh2; y`gensym20596112: cint): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20596113: cint; y`gensym20596114: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20596115: Enum_bass_fxh2; y`gensym20596116: int): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20596117: int; y`gensym20596118: Enum_bass_fxh2): Enum_bass_fxh2 {...}{. raises: [], tags: [].}

proc `$`(x`gensym20596119: Enum_bass_fxh2): string {...}{.borrow.}

proc `not`(x`gensym20596120: Enum_bass_fxh2): Enum_bass_fxh2 {...}{.borrow.}

proc `+`(x`gensym20600959: Enum_bass_fxh3; y`gensym20600960: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `+`(x`gensym20600961: cint; y`gensym20600962: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `+`(x`gensym20600963, y`gensym20600964: Enum_bass_fxh3): Enum_bass_fxh3 {...}{.borrow.}

proc `+`(x`gensym20600965: Enum_bass_fxh3; y`gensym20600966: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `+`(x`gensym20600967: int; y`gensym20600968: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20600969: Enum_bass_fxh3; y`gensym20600970: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `-`(x`gensym20600971: cint; y`gensym20600972: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `-`(x`gensym20600973, y`gensym20600974: Enum_bass_fxh3): Enum_bass_fxh3 {...}{.borrow.}

proc `-`(x`gensym20600975: Enum_bass_fxh3; y`gensym20600976: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20600977: int; y`gensym20600978: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20600979: Enum_bass_fxh3; y`gensym20600980: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `*`(x`gensym20600981: cint; y`gensym20600982: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `*`(x`gensym20600983, y`gensym20600984: Enum_bass_fxh3): Enum_bass_fxh3 {...}{.borrow.}

proc `*`(x`gensym20600985: Enum_bass_fxh3; y`gensym20600986: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20600987: int; y`gensym20600988: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20600989: Enum_bass_fxh3; y`gensym20600990: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `div`(x`gensym20600991: cint; y`gensym20600992: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `div`(x`gensym20600993, y`gensym20600994: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `div`(x`gensym20600995: Enum_bass_fxh3; y`gensym20600996: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20600997: int; y`gensym20600998: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20600999: Enum_bass_fxh3; y`gensym20601000: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `mod`(x`gensym20601001: cint; y`gensym20601002: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `mod`(x`gensym20601003, y`gensym20601004: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `mod`(x`gensym20601005: Enum_bass_fxh3; y`gensym20601006: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20601007: int; y`gensym20601008: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20601009: Enum_bass_fxh3; y`gensym20601010: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `shl`(x`gensym20601011: cint; y`gensym20601012: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `shl`(x`gensym20601013, y`gensym20601014: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `shl`(x`gensym20601015: Enum_bass_fxh3; y`gensym20601016: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20601017: int; y`gensym20601018: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20601019: Enum_bass_fxh3; y`gensym20601020: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `shr`(x`gensym20601021: cint; y`gensym20601022: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `shr`(x`gensym20601023, y`gensym20601024: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `shr`(x`gensym20601025: Enum_bass_fxh3; y`gensym20601026: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20601027: int; y`gensym20601028: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20601029: Enum_bass_fxh3; y`gensym20601030: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `or`(x`gensym20601031: cint; y`gensym20601032: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `or`(x`gensym20601033, y`gensym20601034: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `or`(x`gensym20601035: Enum_bass_fxh3; y`gensym20601036: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20601037: int; y`gensym20601038: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20601039: Enum_bass_fxh3; y`gensym20601040: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `and`(x`gensym20601041: cint; y`gensym20601042: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `and`(x`gensym20601043, y`gensym20601044: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `and`(x`gensym20601045: Enum_bass_fxh3; y`gensym20601046: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20601047: int; y`gensym20601048: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20601049: Enum_bass_fxh3; y`gensym20601050: cint): Enum_bass_fxh3 {...}{. borrow.}

proc `xor`(x`gensym20601051: cint; y`gensym20601052: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `xor`(x`gensym20601053, y`gensym20601054: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. borrow.}

proc `xor`(x`gensym20601055: Enum_bass_fxh3; y`gensym20601056: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20601057: int; y`gensym20601058: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `<`(x`gensym20601059: Enum_bass_fxh3; y`gensym20601060: cint): bool {...}{.borrow.}

proc `<`(x`gensym20601061: cint; y`gensym20601062: Enum_bass_fxh3): bool {...}{.borrow.}

proc `<`(x`gensym20601063, y`gensym20601064: Enum_bass_fxh3): bool {...}{.borrow.}

proc `<`(x`gensym20601065: Enum_bass_fxh3; y`gensym20601066: int): bool {...}{.raises: [], tags: [].}

proc `<`(x`gensym20601067: int; y`gensym20601068: Enum_bass_fxh3): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20601069: Enum_bass_fxh3; y`gensym20601070: cint): bool {...}{.borrow.}

proc `<=`(x`gensym20601071: cint; y`gensym20601072: Enum_bass_fxh3): bool {...}{.borrow.}

proc `<=`(x`gensym20601073, y`gensym20601074: Enum_bass_fxh3): bool {...}{.borrow.}

proc `<=`(x`gensym20601075: Enum_bass_fxh3; y`gensym20601076: int): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20601077: int; y`gensym20601078: Enum_bass_fxh3): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20601079: Enum_bass_fxh3; y`gensym20601080: cint): bool {...}{.borrow.}

proc `==`(x`gensym20601081: cint; y`gensym20601082: Enum_bass_fxh3): bool {...}{.borrow.}

proc `==`(x`gensym20601083, y`gensym20601084: Enum_bass_fxh3): bool {...}{.borrow.}

proc `==`(x`gensym20601085: Enum_bass_fxh3; y`gensym20601086: int): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20601087: int; y`gensym20601088: Enum_bass_fxh3): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20601089: Enum_bass_fxh3; y`gensym20601090: cint): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20601091: cint; y`gensym20601092: Enum_bass_fxh3): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20601093, y`gensym20601094: Enum_bass_fxh3): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20601095: Enum_bass_fxh3; y`gensym20601096: int): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20601097: int; y`gensym20601098: Enum_bass_fxh3): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20601099: Enum_bass_fxh3; y`gensym20601100: cint): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20601101: cint; y`gensym20601102: Enum_bass_fxh3): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20601103, y`gensym20601104: Enum_bass_fxh3): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20601105: Enum_bass_fxh3; y`gensym20601106: int): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20601107: int; y`gensym20601108: Enum_bass_fxh3): bool {...}{.raises: [], tags: [].}

proc `/`(x`gensym20601109, y`gensym20601110: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20601111: Enum_bass_fxh3; y`gensym20601112: cint): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20601113: cint; y`gensym20601114: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20601115: Enum_bass_fxh3; y`gensym20601116: int): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20601117: int; y`gensym20601118: Enum_bass_fxh3): Enum_bass_fxh3 {...}{. raises: [], tags: [].}

proc `$`(x`gensym20601119: Enum_bass_fxh3): string {...}{.borrow.}

proc `not`(x`gensym20601120: Enum_bass_fxh3): Enum_bass_fxh3 {...}{.borrow.}

proc `+`(x`gensym20605959: Enum_bass_fxh4; y`gensym20605960: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `+`(x`gensym20605961: cint; y`gensym20605962: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `+`(x`gensym20605963, y`gensym20605964: Enum_bass_fxh4): Enum_bass_fxh4 {...}{.borrow.}

proc `+`(x`gensym20605965: Enum_bass_fxh4; y`gensym20605966: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `+`(x`gensym20605967: int; y`gensym20605968: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20605969: Enum_bass_fxh4; y`gensym20605970: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `-`(x`gensym20605971: cint; y`gensym20605972: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `-`(x`gensym20605973, y`gensym20605974: Enum_bass_fxh4): Enum_bass_fxh4 {...}{.borrow.}

proc `-`(x`gensym20605975: Enum_bass_fxh4; y`gensym20605976: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20605977: int; y`gensym20605978: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20605979: Enum_bass_fxh4; y`gensym20605980: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `*`(x`gensym20605981: cint; y`gensym20605982: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `*`(x`gensym20605983, y`gensym20605984: Enum_bass_fxh4): Enum_bass_fxh4 {...}{.borrow.}

proc `*`(x`gensym20605985: Enum_bass_fxh4; y`gensym20605986: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20605987: int; y`gensym20605988: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20605989: Enum_bass_fxh4; y`gensym20605990: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `div`(x`gensym20605991: cint; y`gensym20605992: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `div`(x`gensym20605993, y`gensym20605994: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `div`(x`gensym20605995: Enum_bass_fxh4; y`gensym20605996: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20605997: int; y`gensym20605998: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20605999: Enum_bass_fxh4; y`gensym20606000: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `mod`(x`gensym20606001: cint; y`gensym20606002: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `mod`(x`gensym20606003, y`gensym20606004: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `mod`(x`gensym20606005: Enum_bass_fxh4; y`gensym20606006: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20606007: int; y`gensym20606008: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20606009: Enum_bass_fxh4; y`gensym20606010: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `shl`(x`gensym20606011: cint; y`gensym20606012: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `shl`(x`gensym20606013, y`gensym20606014: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `shl`(x`gensym20606015: Enum_bass_fxh4; y`gensym20606016: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20606017: int; y`gensym20606018: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20606019: Enum_bass_fxh4; y`gensym20606020: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `shr`(x`gensym20606021: cint; y`gensym20606022: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `shr`(x`gensym20606023, y`gensym20606024: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `shr`(x`gensym20606025: Enum_bass_fxh4; y`gensym20606026: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20606027: int; y`gensym20606028: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20606029: Enum_bass_fxh4; y`gensym20606030: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `or`(x`gensym20606031: cint; y`gensym20606032: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `or`(x`gensym20606033, y`gensym20606034: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `or`(x`gensym20606035: Enum_bass_fxh4; y`gensym20606036: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20606037: int; y`gensym20606038: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20606039: Enum_bass_fxh4; y`gensym20606040: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `and`(x`gensym20606041: cint; y`gensym20606042: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `and`(x`gensym20606043, y`gensym20606044: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `and`(x`gensym20606045: Enum_bass_fxh4; y`gensym20606046: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20606047: int; y`gensym20606048: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20606049: Enum_bass_fxh4; y`gensym20606050: cint): Enum_bass_fxh4 {...}{. borrow.}

proc `xor`(x`gensym20606051: cint; y`gensym20606052: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `xor`(x`gensym20606053, y`gensym20606054: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. borrow.}

proc `xor`(x`gensym20606055: Enum_bass_fxh4; y`gensym20606056: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20606057: int; y`gensym20606058: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `<`(x`gensym20606059: Enum_bass_fxh4; y`gensym20606060: cint): bool {...}{.borrow.}

proc `<`(x`gensym20606061: cint; y`gensym20606062: Enum_bass_fxh4): bool {...}{.borrow.}

proc `<`(x`gensym20606063, y`gensym20606064: Enum_bass_fxh4): bool {...}{.borrow.}

proc `<`(x`gensym20606065: Enum_bass_fxh4; y`gensym20606066: int): bool {...}{.raises: [], tags: [].}

proc `<`(x`gensym20606067: int; y`gensym20606068: Enum_bass_fxh4): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20606069: Enum_bass_fxh4; y`gensym20606070: cint): bool {...}{.borrow.}

proc `<=`(x`gensym20606071: cint; y`gensym20606072: Enum_bass_fxh4): bool {...}{.borrow.}

proc `<=`(x`gensym20606073, y`gensym20606074: Enum_bass_fxh4): bool {...}{.borrow.}

proc `<=`(x`gensym20606075: Enum_bass_fxh4; y`gensym20606076: int): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20606077: int; y`gensym20606078: Enum_bass_fxh4): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20606079: Enum_bass_fxh4; y`gensym20606080: cint): bool {...}{.borrow.}

proc `==`(x`gensym20606081: cint; y`gensym20606082: Enum_bass_fxh4): bool {...}{.borrow.}

proc `==`(x`gensym20606083, y`gensym20606084: Enum_bass_fxh4): bool {...}{.borrow.}

proc `==`(x`gensym20606085: Enum_bass_fxh4; y`gensym20606086: int): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20606087: int; y`gensym20606088: Enum_bass_fxh4): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20606089: Enum_bass_fxh4; y`gensym20606090: cint): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20606091: cint; y`gensym20606092: Enum_bass_fxh4): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20606093, y`gensym20606094: Enum_bass_fxh4): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20606095: Enum_bass_fxh4; y`gensym20606096: int): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20606097: int; y`gensym20606098: Enum_bass_fxh4): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20606099: Enum_bass_fxh4; y`gensym20606100: cint): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20606101: cint; y`gensym20606102: Enum_bass_fxh4): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20606103, y`gensym20606104: Enum_bass_fxh4): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20606105: Enum_bass_fxh4; y`gensym20606106: int): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20606107: int; y`gensym20606108: Enum_bass_fxh4): bool {...}{.raises: [], tags: [].}

proc `/`(x`gensym20606109, y`gensym20606110: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20606111: Enum_bass_fxh4; y`gensym20606112: cint): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20606113: cint; y`gensym20606114: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20606115: Enum_bass_fxh4; y`gensym20606116: int): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20606117: int; y`gensym20606118: Enum_bass_fxh4): Enum_bass_fxh4 {...}{. raises: [], tags: [].}

proc `$`(x`gensym20606119: Enum_bass_fxh4): string {...}{.borrow.}

proc `not`(x`gensym20606120: Enum_bass_fxh4): Enum_bass_fxh4 {...}{.borrow.}

proc `+`(x`gensym20610959: Enum_bass_fxh5; y`gensym20610960: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `+`(x`gensym20610961: cint; y`gensym20610962: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `+`(x`gensym20610963, y`gensym20610964: Enum_bass_fxh5): Enum_bass_fxh5 {...}{.borrow.}

proc `+`(x`gensym20610965: Enum_bass_fxh5; y`gensym20610966: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `+`(x`gensym20610967: int; y`gensym20610968: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20610969: Enum_bass_fxh5; y`gensym20610970: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `-`(x`gensym20610971: cint; y`gensym20610972: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `-`(x`gensym20610973, y`gensym20610974: Enum_bass_fxh5): Enum_bass_fxh5 {...}{.borrow.}

proc `-`(x`gensym20610975: Enum_bass_fxh5; y`gensym20610976: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `-`(x`gensym20610977: int; y`gensym20610978: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20610979: Enum_bass_fxh5; y`gensym20610980: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `*`(x`gensym20610981: cint; y`gensym20610982: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `*`(x`gensym20610983, y`gensym20610984: Enum_bass_fxh5): Enum_bass_fxh5 {...}{.borrow.}

proc `*`(x`gensym20610985: Enum_bass_fxh5; y`gensym20610986: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `*`(x`gensym20610987: int; y`gensym20610988: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20610989: Enum_bass_fxh5; y`gensym20610990: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `div`(x`gensym20610991: cint; y`gensym20610992: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `div`(x`gensym20610993, y`gensym20610994: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `div`(x`gensym20610995: Enum_bass_fxh5; y`gensym20610996: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `div`(x`gensym20610997: int; y`gensym20610998: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20610999: Enum_bass_fxh5; y`gensym20611000: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `mod`(x`gensym20611001: cint; y`gensym20611002: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `mod`(x`gensym20611003, y`gensym20611004: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `mod`(x`gensym20611005: Enum_bass_fxh5; y`gensym20611006: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `mod`(x`gensym20611007: int; y`gensym20611008: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20611009: Enum_bass_fxh5; y`gensym20611010: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `shl`(x`gensym20611011: cint; y`gensym20611012: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `shl`(x`gensym20611013, y`gensym20611014: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `shl`(x`gensym20611015: Enum_bass_fxh5; y`gensym20611016: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `shl`(x`gensym20611017: int; y`gensym20611018: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20611019: Enum_bass_fxh5; y`gensym20611020: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `shr`(x`gensym20611021: cint; y`gensym20611022: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `shr`(x`gensym20611023, y`gensym20611024: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `shr`(x`gensym20611025: Enum_bass_fxh5; y`gensym20611026: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `shr`(x`gensym20611027: int; y`gensym20611028: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20611029: Enum_bass_fxh5; y`gensym20611030: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `or`(x`gensym20611031: cint; y`gensym20611032: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `or`(x`gensym20611033, y`gensym20611034: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `or`(x`gensym20611035: Enum_bass_fxh5; y`gensym20611036: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `or`(x`gensym20611037: int; y`gensym20611038: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20611039: Enum_bass_fxh5; y`gensym20611040: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `and`(x`gensym20611041: cint; y`gensym20611042: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `and`(x`gensym20611043, y`gensym20611044: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `and`(x`gensym20611045: Enum_bass_fxh5; y`gensym20611046: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `and`(x`gensym20611047: int; y`gensym20611048: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20611049: Enum_bass_fxh5; y`gensym20611050: cint): Enum_bass_fxh5 {...}{. borrow.}

proc `xor`(x`gensym20611051: cint; y`gensym20611052: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `xor`(x`gensym20611053, y`gensym20611054: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. borrow.}

proc `xor`(x`gensym20611055: Enum_bass_fxh5; y`gensym20611056: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `xor`(x`gensym20611057: int; y`gensym20611058: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `<`(x`gensym20611059: Enum_bass_fxh5; y`gensym20611060: cint): bool {...}{.borrow.}

proc `<`(x`gensym20611061: cint; y`gensym20611062: Enum_bass_fxh5): bool {...}{.borrow.}

proc `<`(x`gensym20611063, y`gensym20611064: Enum_bass_fxh5): bool {...}{.borrow.}

proc `<`(x`gensym20611065: Enum_bass_fxh5; y`gensym20611066: int): bool {...}{.raises: [], tags: [].}

proc `<`(x`gensym20611067: int; y`gensym20611068: Enum_bass_fxh5): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20611069: Enum_bass_fxh5; y`gensym20611070: cint): bool {...}{.borrow.}

proc `<=`(x`gensym20611071: cint; y`gensym20611072: Enum_bass_fxh5): bool {...}{.borrow.}

proc `<=`(x`gensym20611073, y`gensym20611074: Enum_bass_fxh5): bool {...}{.borrow.}

proc `<=`(x`gensym20611075: Enum_bass_fxh5; y`gensym20611076: int): bool {...}{.raises: [], tags: [].}

proc `<=`(x`gensym20611077: int; y`gensym20611078: Enum_bass_fxh5): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20611079: Enum_bass_fxh5; y`gensym20611080: cint): bool {...}{.borrow.}

proc `==`(x`gensym20611081: cint; y`gensym20611082: Enum_bass_fxh5): bool {...}{.borrow.}

proc `==`(x`gensym20611083, y`gensym20611084: Enum_bass_fxh5): bool {...}{.borrow.}

proc `==`(x`gensym20611085: Enum_bass_fxh5; y`gensym20611086: int): bool {...}{.raises: [], tags: [].}

proc `==`(x`gensym20611087: int; y`gensym20611088: Enum_bass_fxh5): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20611089: Enum_bass_fxh5; y`gensym20611090: cint): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20611091: cint; y`gensym20611092: Enum_bass_fxh5): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20611093, y`gensym20611094: Enum_bass_fxh5): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20611095: Enum_bass_fxh5; y`gensym20611096: int): bool {...}{.raises: [], tags: [].}

proc `>`(x`gensym20611097: int; y`gensym20611098: Enum_bass_fxh5): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20611099: Enum_bass_fxh5; y`gensym20611100: cint): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20611101: cint; y`gensym20611102: Enum_bass_fxh5): bool {...}{. raises: [], tags: [].}

proc `>=`(x`gensym20611103, y`gensym20611104: Enum_bass_fxh5): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20611105: Enum_bass_fxh5; y`gensym20611106: int): bool {...}{.raises: [], tags: [].}

proc `>=`(x`gensym20611107: int; y`gensym20611108: Enum_bass_fxh5): bool {...}{.raises: [], tags: [].}

proc `/`(x`gensym20611109, y`gensym20611110: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20611111: Enum_bass_fxh5; y`gensym20611112: cint): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20611113: cint; y`gensym20611114: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20611115: Enum_bass_fxh5; y`gensym20611116: int): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `/`(x`gensym20611117: int; y`gensym20611118: Enum_bass_fxh5): Enum_bass_fxh5 {...}{. raises: [], tags: [].}

proc `$`(x`gensym20611119: Enum_bass_fxh5): string {...}{.borrow.}

proc `not`(x`gensym20611120: Enum_bass_fxh5): Enum_bass_fxh5 {...}{.borrow.}

proc BASS_FX_GetVersion(): DWORD {...}{.importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

  BASS_FX Version

proc BASS_FX_TempoCreate(chan: DWORD; flags: DWORD): HSTREAM {...}{.importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_TempoGetSource(chan: HSTREAM): DWORD {...}{.importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_TempoGetRateRatio(chan: HSTREAM): cfloat {...}{.importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_ReverseCreate(chan: DWORD; dec_block: cfloat; flags: DWORD): HSTREAM {...}{. importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_ReverseGetSource(chan: HSTREAM): DWORD {...}{.importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_BPM_DecodeGet(chan: DWORD; startSec: cdouble; endSec: cdouble; minMaxBPM: DWORD; flags: DWORD; `proc`: ptr BPMPROGRESSPROC; user: pointer): cfloat {...}{. importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_BPM_CallbackSet(handle: DWORD; `proc`: ptr BPMPROC; period: cdouble; minMaxBPM: DWORD; flags: DWORD; user: pointer): BOOL {...}{. importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_BPM_CallbackReset(handle: DWORD): BOOL {...}{.importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_BPM_Translate(handle: DWORD; val2tran: cfloat; trans: DWORD): cfloat {...}{. importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

  deprecated

proc BASS_FX_BPM_Free(handle: DWORD): BOOL {...}{.importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

  deprecated

proc BASS_FX_BPM_BeatCallbackSet(handle: DWORD; `proc`: ptr BPMBEATPROC; user: pointer): BOOL {...}{. importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_BPM_BeatCallbackReset(handle: DWORD): BOOL {...}{.importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_BPM_BeatDecodeGet(chan: DWORD; startSec: cdouble; endSec: cdouble; flags: DWORD; `proc`: ptr BPMBEATPROC; user: pointer): BOOL {...}{. importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_BPM_BeatSetParameters(handle: DWORD; bandwidth: cfloat; centerfreq: cfloat; beat_rtime: cfloat): BOOL {...}{. importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_BPM_BeatGetParameters(handle: DWORD; bandwidth: ptr cfloat; centerfreq: ptr cfloat; beat_rtime: ptr cfloat): BOOL {...}{. importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}

proc BASS_FX_BPM_BeatFree(handle: DWORD): BOOL {...}{.importc, cdecl, header: "/home/genotrance/.cache/nim/nimterop/nimbassfx/C/bass_fx.h".}