#version 320 es

#define CITRA_GLES
#if defined(GL_ANDROID_extension_pack_es31a)
#extension GL_ANDROID_extension_pack_es31a : enable
#endif // defined(GL_ANDROID_extension_pack_es31a)
#if defined(GL_EXT_clip_cull_distance)
#extension GL_EXT_clip_cull_distance : enable
#endif // defined(GL_EXT_clip_cull_distance)

#define mul_s(x, y) mix(x * y, vec4(0), isnan(x * y))

#define mul_3(x, y) mix(x * y, vec3(0), isnan(x * y))
#define fma_s(x, y, z) (mul_s(x, y) + z)
#define dot_s(x, y) dot(mul_s(x, y), vec4(1))
#define dot_3(x, y) dot(mul_3(x, y), vec3(1))

#define rcp_s(x) (1.0 / x)

#define rsq_s(x) inversesqrt(x)

#define min_s(x, y) min(x, y)

#define max_s(x, y) max(x, y)
layout(points) in;
layout(triangle_strip, max_vertices=30) out;
layout(location=0) uniform vec4 clip_coef;

layout(binding=3, std140) uniform gs_config {

bool b[16];
uvec4 i[4];
vec4 f[96];
}gs_pica;
bool ExecGS();
layout(location=0) in vec4 vs_out_reg0[];
layout(location=1) in vec4 vs_out_reg1[];
vec4 gs_out_reg[3][2];
vec4 vtx_regs[2] = vec4[2](vec4(1),vec4(1));
layout(location=0) out vec4 primary_color;
layout(location=1) out vec4 texcoord0;
layout(location=2) out vec4 texcoord12;
layout(location=3) out vec4 normquat;
layout(location=4) out vec4 view;
vec4 GetQuaternion(int idx) {
return vec4(1,1,1,1);
}
bool IsOpposite(vec4 qa, vec4 qb) {
return (dot(qa, qb) < 0.0);
}
void EmitVtx(int idx, bool opposite) {
vec4 vtx_pos = vec4(gs_out_reg[idx][0].x,gs_out_reg[idx][0].y,gs_out_reg[idx]
[0].z,gs_out_reg[idx][0].w);
gl_Position = vtx_pos;
#if !defined(CITRA_GLES) || defined(GL_EXT_clip_cull_distance)
gl_ClipDistance[0] = -vtx_pos.z;
gl_ClipDistance[1] = dot(clip_coef, vtx_pos);
#endif
vec4 vtx_quat = GetQuaternion(idx);
normquat = mix(vtx_quat, -vtx_quat, bvec4(opposite));
vec4 vtx_color = vec4(gs_out_reg[idx][1].x,gs_out_reg[idx][1].y,gs_out_reg[idx]
[1].z, gs_out_reg[idx][1].w);
primary_color = clamp(vtx_color,vec4(0),vec4(1));
texcoord0 = vec4(1,1,1,1);
texcoord12 = vec4(1,1,1,1);
view = vec4(1,1,1,1);
EmitVertex();
}
void EmitPrim(int idx0, int idx1, int idx2) {
EmitVtx(idx0, false);
EmitVtx(idx1, IsOpposite(GetQuaternion(idx0), GetQuaternion(idx1)));
EmitVtx(idx2, IsOpposite(GetQuaternion(idx0), GetQuaternion(idx2)));
EndPrimitive();
}

int vtx_idx = 0;
bool prim_emit = false;
bool winding = false;
void SetEmit(int i, bool p, bool w) {
vtx_idx = i;
prim_emit = p;
winding = w;
}
void Emit() {
gs_out_attr[vtx_idx] = vtx_regs;
if (prim_emit) {
if (winding) {
EmitPrim(1,0,2);
winding = false;
} else {
EmitPrim(0,1,2);
}
}
}
void main() {
ExecGS();
}
bvec2 bool_regs = bvec2(false);
ivec3 addr_regs = ivec3(0);
bool Gfn0();
bool Gfn4();
bool Gfn7();
bool Gfn10();
bool Gfn17();
bool Gfn19();
bool Gfn22();
bool Gfn24();
vec4 tmp_reg0;
vec4 tmp_reg1;
vec4 tmp_reg2;
vec4 tmp_reg3;
vec4 tmp_reg4;
vec4 tmp_reg6;
vec4 tmp_reg7;
vec4 tmp_reg8;
vec4 tmp_reg9;
vec4 tmp_reg15;
bool ExecGS() {tmp_reg0 = vec4(0, 0, 0, 1);
tmp_reg1 = vec4(0, 0, 0, 1);
tmp_reg2 = vec4(0, 0, 0, 1);
tmp_reg3 = vec4(0, 0, 0, 1);
tmp_reg4 = vec4(0, 0, 0, 1);
tmp_reg6 = vec4(0, 0, 0, 1);
tmp_reg7 = vec4(0, 0, 0, 1);
tmp_reg8 = vec4(0, 0, 0, 1);
tmp_reg9 = vec4(0, 0, 0, 1);
tmp_reg15 = vec4(0, 0, 0, 1);
Gfn0();
return true;
}

bool Gfn0() {
tmp_reg0.x = (tmp_reg7.wwww).x;
if (gs_pica.b[15]) {
tmp_reg0.y = (gs_pica.f[76].yyyy).y;
} else {
tmp_reg0.y = (gs_pica.f[76].xxxx).y;
tmp_reg15.x = rcp_s(gs_pica.f[67].x);
tmp_reg15.y = rcp_s(gs_pica.f[67].y);
}
bool_regs = equal(gs_pica.f[76].xx, tmp_reg0.xy);
tmp_reg0.x = (tmp_reg8.zzzz).x;
if (any(bool_regs)) {
tmp_reg7 = gs_pica.f[76].xxxx;
} else {
Gfn4();
}
tmp_reg7.w = (gs_pica.f[76].yyyy + tmp_reg7.wwww).w;
tmp_reg8 = vs_out_reg0[0];
bool_regs = equal(gs_pica.f[76].zz, tmp_reg7.ww);
tmp_reg9 = vs_out_reg1[0];
if (bool_regs.x) {
tmp_reg7.w = (gs_pica.f[76].xxxx).w;
}
return true;
}
bool Gfn4() {
uint jmp_to = 38u;
while (true) {
switch (jmp_to) {
case 38u:
tmp_reg0.y = (vs_out_reg0[0].zzzz).y;
bool_regs = lessThan(gs_pica.f[76].xx, tmp_reg0.xy);
tmp_reg6.x = (vec4(lessThan(tmp_reg7.wwww, gs_pica.f[76].zzzz))).x;
tmp_reg1 = vs_out_reg0[0];
if (all(bool_regs)) {
jmp_to = 174u; break;
}
if (all(not(bool_regs))) {
jmp_to = 63u; break;
}
if (all(bvec2(bool_regs.x, !bool_regs.y))) {
tmp_reg0 = tmp_reg8.zzzz + -vs_out_reg0[0].zzzz;
tmp_reg0 = vec4(rcp_s(tmp_reg0.x));
tmp_reg6.x = (gs_pica.f[76].yyyy).x;
tmp_reg1.x = (mul_s(tmp_reg0, tmp_reg8.zzzz)).x;
tmp_reg1.y = (mul_s(-tmp_reg0, vs_out_reg0[0].zzzz)).y;
tmp_reg8 = mul_s(tmp_reg1.yyyy, tmp_reg8);
tmp_reg9 = mul_s(tmp_reg1.yyyy, tmp_reg9);
tmp_reg8 = fma_s(tmp_reg1.xxxx, vs_out_reg0[0], tmp_reg8);
tmp_reg9 = fma_s(tmp_reg1.xxxx, vs_out_reg1[0], tmp_reg9);
tmp_reg8.z = (gs_pica.f[76].xxxx).z;
tmp_reg1 = vs_out_reg0[0];
} else {
tmp_reg0 = vs_out_reg0[0].zzzz + -tmp_reg8.zzzz;
tmp_reg0 = vec4(rcp_s(tmp_reg0.x));
tmp_reg0.x = (mul_s(tmp_reg0, vs_out_reg0[0].zzzz)).x;
tmp_reg0.y = (mul_s(-tmp_reg0, tmp_reg8.zzzz)).y;
tmp_reg1 = mul_s(tmp_reg0.yyyy, vs_out_reg0[0]);
tmp_reg1 = fma_s(tmp_reg0.xxxx, tmp_reg8, tmp_reg1);
tmp_reg1.z = (gs_pica.f[76].xxxx).z;
}
case 63u:
tmp_reg0.xy = (mul_s(tmp_reg8, tmp_reg1.wwww)).xy;
tmp_reg3.z = (tmp_reg6.xxxx).z;
tmp_reg2 = gs_pica.f[76].xxxx;
tmp_reg0.xy = (fma_s(tmp_reg1, tmp_reg8.wwww, -tmp_reg0)).xy;
tmp_reg3.w = (gs_pica.f[76].xxxx).w;
tmp_reg2.y = (tmp_reg1.wwww).y;
tmp_reg1.xy = (abs(tmp_reg0)).xy;
tmp_reg1.xy = (mul_s(tmp_reg1, tmp_reg15.yxxx)).xy;
bool_regs.x = tmp_reg1.xxxx.x > tmp_reg1.yyyy.x;
bool_regs.y = tmp_reg1.xxxx.y == tmp_reg1.yyyy.y;
tmp_reg1 = gs_pica.f[76].xxxx;
if (bool_regs.x) {
Gfn7();
} else {
Gfn10();
}
bool_regs.x = tmp_reg3.xzzz.x == tmp_reg3.ywww.x;
bool_regs.y = tmp_reg3.xzzz.y > tmp_reg3.ywww.y;
if (any(bvec2(!bool_regs.x, bool_regs.y))) {
bool_regs.x = gs_pica.f[76].xxxx.x >= vs_out_reg0[0].zzzz.x;
bool_regs.y = gs_pica.f[76].xxxx.y == vs_out_reg0[0].zzzz.y;
vtx_regs[1] = tmp_reg9;
SetEmit(0, false, false);
vtx_regs[0] = tmp_reg8 + tmp_reg1;
Emit();
SetEmit(1, false, false);
Emit();
vtx_regs[0] = tmp_reg8 + -tmp_reg1;
SetEmit(1, false, false);
tmp_reg7.z = (gs_pica.f[76].zzzz).z;
Emit();
} else {
bool_regs.x = gs_pica.f[76].xxxx.x >= vs_out_reg0[0].zzzz.x;
bool_regs.y = gs_pica.f[76].xxxx.y == vs_out_reg0[0].zzzz.y;
}
if (bool_regs.x) {
bool_regs = lessThan(gs_pica.f[76].xx, tmp_reg7.yy);
tmp_reg3 = vs_out_reg0[0];
vtx_regs[1] = vs_out_reg1[0];
} else {
bool_regs = lessThan(gs_pica.f[76].xx, tmp_reg7.yy);
tmp_reg1 = vs_out_reg0[0].zzzz + -tmp_reg8.zzzz;
tmp_reg1 = vec4(rcp_s(tmp_reg1.x));
tmp_reg3.x = (mul_s(tmp_reg1, vs_out_reg0[0].zzzz)).x;
tmp_reg3.y = (mul_s(-tmp_reg1, tmp_reg8.zzzz)).y;
tmp_reg1 = mul_s(tmp_reg3.yyyy, vs_out_reg0[0]);
tmp_reg4 = mul_s(tmp_reg3.yyyy, vs_out_reg1[0]);
tmp_reg1 = fma_s(tmp_reg3.xxxx, tmp_reg8, tmp_reg1);
tmp_reg1.z = (gs_pica.f[76].xxxx).z;
vtx_regs[1] = fma_s(tmp_reg3.xxxx, tmp_reg9, tmp_reg4);
tmp_reg3 = tmp_reg1;
}
if (bool_regs.x) {
Gfn17();
} else {
Gfn22();
}
case 174u:
tmp_reg7.x = (tmp_reg7.yyyy).x;
default: return false;
}
}
return false;
}
bool Gfn7() {
bool_regs.x = gs_pica.f[76].xxxx.x < tmp_reg0.xxxx.x;
bool_regs.y = gs_pica.f[76].xxxx.y == tmp_reg0.xxxx.y;
tmp_reg2.y = (mul_s(tmp_reg2.yyyy, tmp_reg15.yyyy)).y;
tmp_reg1.y = (mul_s(tmp_reg8.wwww, tmp_reg15.yyyy)).y;
if (bool_regs.x) {
tmp_reg7.y = (gs_pica.f[76].yyyy).y;
} else {
tmp_reg7.y = (-gs_pica.f[76].yyyy).y;
}
tmp_reg3.xy = (abs(tmp_reg7)).xy;
return false;
}
bool Gfn10() {
tmp_reg2.y = (mul_s(tmp_reg2.yyyy, tmp_reg15.xxxx)).y;
bool_regs.x = gs_pica.f[76].xxxx.x < tmp_reg0.yyyy.x;
bool_regs.y = gs_pica.f[76].xxxx.y == tmp_reg0.yyyy.y;
tmp_reg1.x = (mul_s(-tmp_reg8.wwww, tmp_reg15.xxxx)).x;
tmp_reg2.x = (-tmp_reg2.yyyy).x;
if (bool_regs.x) {
tmp_reg7.y = (gs_pica.f[76].zzzz).y;
} else {
tmp_reg7.y = (-gs_pica.f[76].zzzz).y;
}
tmp_reg3.xy = (abs(tmp_reg7)).xy;
tmp_reg2.y = (gs_pica.f[76].xxxx).y;
return false;
}
bool Gfn17() {
bool_regs = equal(gs_pica.f[76].xy, tmp_reg7.zz);
vtx_regs[0] = tmp_reg3 + tmp_reg2;
if (bool_regs.x) {
SetEmit(0, true, false);
Emit();
SetEmit(1, false, true);
Emit();
vtx_regs[0] = tmp_reg3 + -tmp_reg2;
SetEmit(1, true, true);
tmp_reg7.z = (gs_pica.f[76].zzzz).z;
} else {
Gfn19();
}
Emit();
return false;
}
bool Gfn19() {
if (bool_regs.y) {
SetEmit(1, true, false);
Emit();
SetEmit(2, false, true);
Emit();
vtx_regs[0] = tmp_reg3 + -tmp_reg2;
SetEmit(2, true, true);
tmp_reg7.z = (gs_pica.f[76].xxxx).z;
} else {
SetEmit(2, true, false);
Emit();
SetEmit(0, false, true);
Emit();
vtx_regs[0] = tmp_reg3 + -tmp_reg2;
SetEmit(0, true, true);
tmp_reg7.z = (gs_pica.f[76].yyyy).z;
}
return false;
}
bool Gfn22() {
bool_regs = equal(gs_pica.f[76].xy, tmp_reg7.zz);
vtx_regs[0] = tmp_reg3 + tmp_reg2;
if (bool_regs.x) {
SetEmit(0, true, true);
Emit();
SetEmit(1, false, false);
Emit();
vtx_regs[0] = tmp_reg3 + -tmp_reg2;
SetEmit(1, true, false);
tmp_reg7.z = (gs_pica.f[76].zzzz).z;
} else {
Gfn24();
}
Emit();
return false;
}
bool Gfn24() {
if (bool_regs.y) {
SetEmit(1, true, true);
Emit();
SetEmit(2, false, false);
Emit();
vtx_regs[0] = tmp_reg3 + -tmp_reg2;
SetEmit(2, true, false);
tmp_reg7.z = (gs_pica.f[76].xxxx).z;
} else {
SetEmit(2, true, true);
Emit();
SetEmit(0, false, false);
Emit();
vtx_regs[0] = tmp_reg3 + -tmp_reg2;
SetEmit(0, true, false);
tmp_reg7.z = (gs_pica.f[76].yyyy).z;
}
return false;
}
ERROR: 0:78: 'gs_out_attr' : undeclared identifier
ERROR: 0:78: 'expression' : left of '[' is not of type array, matrix, or vector
ERROR: 0:78: 'assign' : cannot convert from 'array of 4-component vector of float'
to 'float'
ERROR: 3 compilation errors. No code generated.