18059902851

Committed 27 Sep 2025 12:32PM UTC coverage: 74.093% (+0.04%) from 74.05%

Build # 18059902851

Build Type

push

github

Committed by

Razakhel

Commit Message

[Utils/Logger] Added formatted logging overloads

- Formatted calls to logging functions and made use of std::format() in several other places

Run Details

100 of 170 new or added lines in 36 files covered. (58.82%)

4 existing lines in 2 files now uncovered.

8334 of 11248 relevant lines covered (74.09%)

1757.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.93

/src/RaZ/Audio/SoundEffect.cpp

#include "RaZ/Audio/SoundEffect.hpp"
#include "RaZ/Utils/CompilerUtils.hpp"
#include "RaZ/Utils/Logger.hpp"

#include "tracy/Tracy.hpp"

#include <AL/efx.h>
#include <AL/efx-presets.h>

namespace Raz {

namespace {

constexpr const char* recoverAlErrorStr(int errorCode) {
  switch (errorCode) {
    case AL_INVALID_NAME:      return "Invalid name";
    case AL_INVALID_ENUM:      return "Invalid enum";
    case AL_INVALID_VALUE:     return "Invalid value";
    case AL_INVALID_OPERATION: return "Invalid operation";
    case AL_OUT_OF_MEMORY:     return "Out of memory";
    case AL_NO_ERROR:          return "No error";
    default:                   return "Unknown error";
  }
}

inline void checkError(const std::string& errorMsg) {
  const int errorCode = alGetError();

  if (errorCode != AL_NO_ERROR)
    Logger::error("[OpenAL] {} ({})", errorMsg, recoverAlErrorStr(errorCode));
}

// Effect functions
LPALGENEFFECTS alGenEffects;
LPALDELETEEFFECTS alDeleteEffects;
LPALISEFFECT alIsEffect;
LPALEFFECTI alEffecti;
//LPALEFFECTIV alEffectiv;
LPALEFFECTF alEffectf;
LPALEFFECTFV alEffectfv;
//LPALGETEFFECTI alGetEffecti;
//LPALGETEFFECTIV alGetEffectiv;
//LPALGETEFFECTF alGetEffectf;
//LPALGETEFFECTFV alGetEffectfv;

inline bool loadFunctions() noexcept {
  PUSH_WARNINGS_STATE
  DISABLE_WARNING_GCC(-Wconditionally-supported)

  alGenEffects    = reinterpret_cast<LPALGENEFFECTS>(alGetProcAddress("alGenEffects"));
  alDeleteEffects = reinterpret_cast<LPALDELETEEFFECTS>(alGetProcAddress("alDeleteEffects"));
  alIsEffect      = reinterpret_cast<LPALISEFFECT>(alGetProcAddress("alIsEffect"));
  alEffecti       = reinterpret_cast<LPALEFFECTI>(alGetProcAddress("alEffecti"));
  //alEffectiv      = reinterpret_cast<LPALEFFECTIV>(alGetProcAddress("alEffectiv"));
  alEffectf       = reinterpret_cast<LPALEFFECTF>(alGetProcAddress("alEffectf"));
  alEffectfv      = reinterpret_cast<LPALEFFECTFV>(alGetProcAddress("alEffectfv"));
  //alGetEffecti    = reinterpret_cast<LPALGETEFFECTI>(alGetProcAddress("alGetEffecti"));
  //alGetEffectiv   = reinterpret_cast<LPALGETEFFECTIV>(alGetProcAddress("alGetEffectiv"));
  //alGetEffectf    = reinterpret_cast<LPALGETEFFECTF>(alGetProcAddress("alGetEffectf"));
  //alGetEffectfv   = reinterpret_cast<LPALGETEFFECTFV>(alGetProcAddress("alGetEffectfv"));

  POP_WARNINGS_STATE

  return true;
}

} // namespace

void SoundEffect::init() {
  ZoneScopedN("SoundEffect::init");

  if (!alcIsExtensionPresent(alcGetContextsDevice(alcGetCurrentContext()), "ALC_EXT_EFX")) {
    Logger::error("[SoundEffect] Sound effects are unavailable");
    return;
  }

  [[maybe_unused]] static const bool funcsLoaded = loadFunctions();

  Logger::debug("[SoundEffect] Initializing...");

  alGetError(); // Flushing errors

  destroy();

  alGenEffects(1, &m_index.get());
  checkError("Failed to create a sound effect");

  Logger::debug("[SoundEffect] Initialized (ID: {})", m_index.get());
}

void SoundEffect::load(const ReverberationParams& params) {
  alGetError(); // Flushing errors

  if (alGetEnumValue("AL_EFFECT_EAXREVERB") != 0) {
    alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);

    alEffectf(m_index, AL_EAXREVERB_DENSITY, params.density);
    alEffectf(m_index, AL_EAXREVERB_DIFFUSION, params.diffusion);
    alEffectf(m_index, AL_EAXREVERB_GAIN, params.gain);
    alEffectf(m_index, AL_EAXREVERB_GAINHF, params.gainHighFrequency);
    alEffectf(m_index, AL_EAXREVERB_GAINLF, params.gainLowFrequency);
    alEffectf(m_index, AL_EAXREVERB_DECAY_TIME, params.decayTime);
    alEffectf(m_index, AL_EAXREVERB_DECAY_HFRATIO, params.decayHighFrequencyRatio);
    alEffectf(m_index, AL_EAXREVERB_DECAY_LFRATIO, params.decayLowFrequencyRatio);
    alEffectf(m_index, AL_EAXREVERB_REFLECTIONS_GAIN, params.reflectionsGain);
    alEffectf(m_index, AL_EAXREVERB_REFLECTIONS_DELAY, params.reflectionsDelay);
    alEffectfv(m_index, AL_EAXREVERB_REFLECTIONS_PAN, params.reflectionsPan.data());
    alEffectf(m_index, AL_EAXREVERB_LATE_REVERB_GAIN, params.lateReverbGain);
    alEffectf(m_index, AL_EAXREVERB_LATE_REVERB_DELAY, params.lateReverbDelay);
    alEffectfv(m_index, AL_EAXREVERB_LATE_REVERB_PAN, params.lateReverbPan.data());
    alEffectf(m_index, AL_EAXREVERB_ECHO_TIME, params.echoTime);
    alEffectf(m_index, AL_EAXREVERB_ECHO_DEPTH, params.echoDepth);
    alEffectf(m_index, AL_EAXREVERB_MODULATION_TIME, params.modulationTime);
    alEffectf(m_index, AL_EAXREVERB_MODULATION_DEPTH, params.modulationDepth);
    alEffectf(m_index, AL_EAXREVERB_AIR_ABSORPTION_GAINHF, params.airAbsorptionGainHighFrequency);
    alEffectf(m_index, AL_EAXREVERB_HFREFERENCE, params.highFrequencyReference);
    alEffectf(m_index, AL_EAXREVERB_LFREFERENCE, params.lowFrequencyReference);
    alEffectf(m_index, AL_EAXREVERB_ROOM_ROLLOFF_FACTOR, params.roomRolloffFactor);
    alEffecti(m_index, AL_EAXREVERB_DECAY_HFLIMIT, params.decayHighFrequencyLimit);
  } else {
    alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_REVERB);

    alEffectf(m_index, AL_REVERB_DENSITY, params.density);
    alEffectf(m_index, AL_REVERB_DIFFUSION, params.diffusion);
    alEffectf(m_index, AL_REVERB_GAIN, params.gain);
    alEffectf(m_index, AL_REVERB_GAINHF, params.gainHighFrequency);
    alEffectf(m_index, AL_REVERB_DECAY_TIME, params.decayTime);
    alEffectf(m_index, AL_REVERB_DECAY_HFRATIO, params.decayHighFrequencyRatio);
    alEffectf(m_index, AL_REVERB_REFLECTIONS_GAIN, params.reflectionsGain);
    alEffectf(m_index, AL_REVERB_REFLECTIONS_DELAY, params.reflectionsDelay);
    alEffectf(m_index, AL_REVERB_LATE_REVERB_GAIN, params.lateReverbGain);
    alEffectf(m_index, AL_REVERB_LATE_REVERB_DELAY, params.lateReverbDelay);
    alEffectf(m_index, AL_REVERB_AIR_ABSORPTION_GAINHF, params.airAbsorptionGainHighFrequency);
    alEffectf(m_index, AL_REVERB_ROOM_ROLLOFF_FACTOR, params.roomRolloffFactor);
    alEffecti(m_index, AL_REVERB_DECAY_HFLIMIT, params.decayHighFrequencyLimit);
  }

  checkError("Failed to set the reverberation effect");
}

void SoundEffect::load(const ChorusParams& params) {
  alGetError(); // Flushing errors

  alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_CHORUS);

  if (alGetError() != AL_NO_ERROR) {
    Logger::error("[OpenAL] Failed to set the chorus effect");
    return;
  }

  alEffecti(m_index, AL_CHORUS_WAVEFORM, static_cast<int>(params.waveform));
  alEffecti(m_index, AL_CHORUS_PHASE, params.phase);
  alEffectf(m_index, AL_CHORUS_RATE, params.rate);
  alEffectf(m_index, AL_CHORUS_DEPTH, params.depth);
  alEffectf(m_index, AL_CHORUS_FEEDBACK, params.feedback);
  alEffectf(m_index, AL_CHORUS_DELAY, params.delay);

  checkError("Failed to set the chorus effect's parameters");
}

void SoundEffect::load(const DistortionParams& params) {
  alGetError(); // Flushing errors

  alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_DISTORTION);

  if (alGetError() != AL_NO_ERROR) {
    Logger::error("[OpenAL] Failed to set the distortion effect");
    return;
  }

  alEffectf(m_index, AL_DISTORTION_EDGE, params.edge);
  alEffectf(m_index, AL_DISTORTION_GAIN, params.gain);
  alEffectf(m_index, AL_DISTORTION_LOWPASS_CUTOFF, params.lowpassCutoff);
  alEffectf(m_index, AL_DISTORTION_EQCENTER, params.eqCenter);
  alEffectf(m_index, AL_DISTORTION_EQBANDWIDTH, params.eqBandwidth);

  checkError("Failed to set the distortion effect's parameters");
}

void SoundEffect::load(const EchoParams& params) {
  alGetError(); // Flushing errors

  alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_ECHO);

  if (alGetError() != AL_NO_ERROR) {
    Logger::error("[OpenAL] Failed to set the echo effect");
    return;
  }

  alEffectf(m_index, AL_ECHO_DELAY, params.delay);
  alEffectf(m_index, AL_ECHO_LRDELAY, params.leftRightDelay);
  alEffectf(m_index, AL_ECHO_DAMPING, params.damping);
  alEffectf(m_index, AL_ECHO_FEEDBACK, params.feedback);
  alEffectf(m_index, AL_ECHO_SPREAD, params.spread);

  checkError("Failed to set the echo effect's parameters");
}

void SoundEffect::reset() {
  alGetError(); // Flushing errors

  alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_NULL);
  checkError("Failed to reset the effect");
}

void SoundEffect::destroy() {
  ZoneScopedN("SoundEffect::destroy");

  if (!m_index.isValid())
    return;

  Logger::debug("[SoundEffect] Destroying (ID: {})...", m_index.get());

  if (alIsEffect(m_index)) {
    alDeleteEffects(1, &m_index.get());
    checkError("Failed to delete sound effect");
  }

  m_index.reset();

  Logger::debug("[SoundEffect] Destroyed");
}

} // namespace Raz

1	#include "RaZ/Audio/SoundEffect.hpp"
2	#include "RaZ/Utils/CompilerUtils.hpp"
3	#include "RaZ/Utils/Logger.hpp"
4
5	#include "tracy/Tracy.hpp"
6
7	#include <AL/efx.h>
8	#include <AL/efx-presets.h>
9
10	namespace Raz {
11
12	namespace {
13
14	constexpr const char* recoverAlErrorStr(int errorCode) {	×
15	switch (errorCode) {	×
16	case AL_INVALID_NAME: return "Invalid name";	×
17	case AL_INVALID_ENUM: return "Invalid enum";	×
18	case AL_INVALID_VALUE: return "Invalid value";	×
19	case AL_INVALID_OPERATION: return "Invalid operation";	×
20	case AL_OUT_OF_MEMORY: return "Out of memory";	×
21	case AL_NO_ERROR: return "No error";	×
22	default: return "Unknown error";	×
23	}
24	}
25
26	inline void checkError(const std::string& errorMsg) {	11✔
27	const int errorCode = alGetError();	11✔
28
29	if (errorCode != AL_NO_ERROR)	11✔
NEW 30	Logger::error("[OpenAL] {} ({})", errorMsg, recoverAlErrorStr(errorCode));	×
31	}	11✔
32
33	// Effect functions
34	LPALGENEFFECTS alGenEffects;
35	LPALDELETEEFFECTS alDeleteEffects;
36	LPALISEFFECT alIsEffect;
37	LPALEFFECTI alEffecti;
38	//LPALEFFECTIV alEffectiv;
39	LPALEFFECTF alEffectf;
40	LPALEFFECTFV alEffectfv;
41	//LPALGETEFFECTI alGetEffecti;
42	//LPALGETEFFECTIV alGetEffectiv;
43	//LPALGETEFFECTF alGetEffectf;
44	//LPALGETEFFECTFV alGetEffectfv;
45
46	inline bool loadFunctions() noexcept {	1✔
47	PUSH_WARNINGS_STATE
48	DISABLE_WARNING_GCC(-Wconditionally-supported)
49
50	alGenEffects = reinterpret_cast<LPALGENEFFECTS>(alGetProcAddress("alGenEffects"));	1✔
51	alDeleteEffects = reinterpret_cast<LPALDELETEEFFECTS>(alGetProcAddress("alDeleteEffects"));	1✔
52	alIsEffect = reinterpret_cast<LPALISEFFECT>(alGetProcAddress("alIsEffect"));	1✔
53	alEffecti = reinterpret_cast<LPALEFFECTI>(alGetProcAddress("alEffecti"));	1✔
54	//alEffectiv = reinterpret_cast<LPALEFFECTIV>(alGetProcAddress("alEffectiv"));
55	alEffectf = reinterpret_cast<LPALEFFECTF>(alGetProcAddress("alEffectf"));	1✔
56	alEffectfv = reinterpret_cast<LPALEFFECTFV>(alGetProcAddress("alEffectfv"));	1✔
57	//alGetEffecti = reinterpret_cast<LPALGETEFFECTI>(alGetProcAddress("alGetEffecti"));
58	//alGetEffectiv = reinterpret_cast<LPALGETEFFECTIV>(alGetProcAddress("alGetEffectiv"));
59	//alGetEffectf = reinterpret_cast<LPALGETEFFECTF>(alGetProcAddress("alGetEffectf"));
60	//alGetEffectfv = reinterpret_cast<LPALGETEFFECTFV>(alGetProcAddress("alGetEffectfv"));
61
62	POP_WARNINGS_STATE
63
64	return true;	1✔
65	}
66
67	} // namespace
68
69	void SoundEffect::init() {	3✔
70	ZoneScopedN("SoundEffect::init");
71
72	if (!alcIsExtensionPresent(alcGetContextsDevice(alcGetCurrentContext()), "ALC_EXT_EFX")) {	3✔
73	Logger::error("[SoundEffect] Sound effects are unavailable");	×
74	return;	×
75	}
76
77	[[maybe_unused]] static const bool funcsLoaded = loadFunctions();	3✔
78
79	Logger::debug("[SoundEffect] Initializing...");	3✔
80
81	alGetError(); // Flushing errors	3✔
82
83	destroy();	3✔
84
85	alGenEffects(1, &m_index.get());	3✔
86	checkError("Failed to create a sound effect");	3✔
87
88	Logger::debug("[SoundEffect] Initialized (ID: {})", m_index.get());	3✔
89	}
90
91	void SoundEffect::load(const ReverberationParams& params) {	1✔
92	alGetError(); // Flushing errors	1✔
93
94	if (alGetEnumValue("AL_EFFECT_EAXREVERB") != 0) {	1✔
95	alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);	1✔
96
97	alEffectf(m_index, AL_EAXREVERB_DENSITY, params.density);	1✔
98	alEffectf(m_index, AL_EAXREVERB_DIFFUSION, params.diffusion);	1✔
99	alEffectf(m_index, AL_EAXREVERB_GAIN, params.gain);	1✔
100	alEffectf(m_index, AL_EAXREVERB_GAINHF, params.gainHighFrequency);	1✔
101	alEffectf(m_index, AL_EAXREVERB_GAINLF, params.gainLowFrequency);	1✔
102	alEffectf(m_index, AL_EAXREVERB_DECAY_TIME, params.decayTime);	1✔
103	alEffectf(m_index, AL_EAXREVERB_DECAY_HFRATIO, params.decayHighFrequencyRatio);	1✔
104	alEffectf(m_index, AL_EAXREVERB_DECAY_LFRATIO, params.decayLowFrequencyRatio);	1✔
105	alEffectf(m_index, AL_EAXREVERB_REFLECTIONS_GAIN, params.reflectionsGain);	1✔
106	alEffectf(m_index, AL_EAXREVERB_REFLECTIONS_DELAY, params.reflectionsDelay);	1✔
107	alEffectfv(m_index, AL_EAXREVERB_REFLECTIONS_PAN, params.reflectionsPan.data());	1✔
108	alEffectf(m_index, AL_EAXREVERB_LATE_REVERB_GAIN, params.lateReverbGain);	1✔
109	alEffectf(m_index, AL_EAXREVERB_LATE_REVERB_DELAY, params.lateReverbDelay);	1✔
110	alEffectfv(m_index, AL_EAXREVERB_LATE_REVERB_PAN, params.lateReverbPan.data());	1✔
111	alEffectf(m_index, AL_EAXREVERB_ECHO_TIME, params.echoTime);	1✔
112	alEffectf(m_index, AL_EAXREVERB_ECHO_DEPTH, params.echoDepth);	1✔
113	alEffectf(m_index, AL_EAXREVERB_MODULATION_TIME, params.modulationTime);	1✔
114	alEffectf(m_index, AL_EAXREVERB_MODULATION_DEPTH, params.modulationDepth);	1✔
115	alEffectf(m_index, AL_EAXREVERB_AIR_ABSORPTION_GAINHF, params.airAbsorptionGainHighFrequency);	1✔
116	alEffectf(m_index, AL_EAXREVERB_HFREFERENCE, params.highFrequencyReference);	1✔
117	alEffectf(m_index, AL_EAXREVERB_LFREFERENCE, params.lowFrequencyReference);	1✔
118	alEffectf(m_index, AL_EAXREVERB_ROOM_ROLLOFF_FACTOR, params.roomRolloffFactor);	1✔
119	alEffecti(m_index, AL_EAXREVERB_DECAY_HFLIMIT, params.decayHighFrequencyLimit);	1✔
120	} else {
121	alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_REVERB);	×
122
123	alEffectf(m_index, AL_REVERB_DENSITY, params.density);	×
124	alEffectf(m_index, AL_REVERB_DIFFUSION, params.diffusion);	×
125	alEffectf(m_index, AL_REVERB_GAIN, params.gain);	×
126	alEffectf(m_index, AL_REVERB_GAINHF, params.gainHighFrequency);	×
127	alEffectf(m_index, AL_REVERB_DECAY_TIME, params.decayTime);	×
128	alEffectf(m_index, AL_REVERB_DECAY_HFRATIO, params.decayHighFrequencyRatio);	×
129	alEffectf(m_index, AL_REVERB_REFLECTIONS_GAIN, params.reflectionsGain);	×
130	alEffectf(m_index, AL_REVERB_REFLECTIONS_DELAY, params.reflectionsDelay);	×
131	alEffectf(m_index, AL_REVERB_LATE_REVERB_GAIN, params.lateReverbGain);	×
132	alEffectf(m_index, AL_REVERB_LATE_REVERB_DELAY, params.lateReverbDelay);	×
133	alEffectf(m_index, AL_REVERB_AIR_ABSORPTION_GAINHF, params.airAbsorptionGainHighFrequency);	×
134	alEffectf(m_index, AL_REVERB_ROOM_ROLLOFF_FACTOR, params.roomRolloffFactor);	×
135	alEffecti(m_index, AL_REVERB_DECAY_HFLIMIT, params.decayHighFrequencyLimit);	×
136	}
137
138	checkError("Failed to set the reverberation effect");	1✔
139	}	1✔
140
141	void SoundEffect::load(const ChorusParams& params) {	1✔
142	alGetError(); // Flushing errors	1✔
143
144	alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_CHORUS);	1✔
145
146	if (alGetError() != AL_NO_ERROR) {	1✔
147	Logger::error("[OpenAL] Failed to set the chorus effect");	×
148	return;	×
149	}
150
151	alEffecti(m_index, AL_CHORUS_WAVEFORM, static_cast<int>(params.waveform));	1✔
152	alEffecti(m_index, AL_CHORUS_PHASE, params.phase);	1✔
153	alEffectf(m_index, AL_CHORUS_RATE, params.rate);	1✔
154	alEffectf(m_index, AL_CHORUS_DEPTH, params.depth);	1✔
155	alEffectf(m_index, AL_CHORUS_FEEDBACK, params.feedback);	1✔
156	alEffectf(m_index, AL_CHORUS_DELAY, params.delay);	1✔
157
158	checkError("Failed to set the chorus effect's parameters");	2✔
159	}
160
161	void SoundEffect::load(const DistortionParams& params) {	2✔
162	alGetError(); // Flushing errors	2✔
163
164	alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_DISTORTION);	2✔
165
166	if (alGetError() != AL_NO_ERROR) {	2✔
167	Logger::error("[OpenAL] Failed to set the distortion effect");	×
168	return;	×
169	}
170
171	alEffectf(m_index, AL_DISTORTION_EDGE, params.edge);	2✔
172	alEffectf(m_index, AL_DISTORTION_GAIN, params.gain);	2✔
173	alEffectf(m_index, AL_DISTORTION_LOWPASS_CUTOFF, params.lowpassCutoff);	2✔
174	alEffectf(m_index, AL_DISTORTION_EQCENTER, params.eqCenter);	2✔
175	alEffectf(m_index, AL_DISTORTION_EQBANDWIDTH, params.eqBandwidth);	2✔
176
177	checkError("Failed to set the distortion effect's parameters");	4✔
178	}
179
180	void SoundEffect::load(const EchoParams& params) {	×
181	alGetError(); // Flushing errors	×
182
183	alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_ECHO);	×
184
185	if (alGetError() != AL_NO_ERROR) {	×
186	Logger::error("[OpenAL] Failed to set the echo effect");	×
187	return;	×
188	}
189
190	alEffectf(m_index, AL_ECHO_DELAY, params.delay);	×
191	alEffectf(m_index, AL_ECHO_LRDELAY, params.leftRightDelay);	×
192	alEffectf(m_index, AL_ECHO_DAMPING, params.damping);	×
193	alEffectf(m_index, AL_ECHO_FEEDBACK, params.feedback);	×
194	alEffectf(m_index, AL_ECHO_SPREAD, params.spread);	×
195
196	checkError("Failed to set the echo effect's parameters");	×
197	}
198
199	void SoundEffect::reset() {	1✔
200	alGetError(); // Flushing errors	1✔
201
202	alEffecti(m_index, AL_EFFECT_TYPE, AL_EFFECT_NULL);	1✔
203	checkError("Failed to reset the effect");	1✔
204	}	1✔
205
206	void SoundEffect::destroy() {	6✔
207	ZoneScopedN("SoundEffect::destroy");
208
209	if (!m_index.isValid())	6✔
210	return;	3✔
211
212	Logger::debug("[SoundEffect] Destroying (ID: {})...", m_index.get());	3✔
213
214	if (alIsEffect(m_index)) {	3✔
215	alDeleteEffects(1, &m_index.get());	3✔
216	checkError("Failed to delete sound effect");	6✔
217	}
218
219	m_index.reset();	3✔
220
221	Logger::debug("[SoundEffect] Destroyed");	6✔
222	}
223
224	} // namespace Raz

Razakhel / RaZ / 18059902851

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous