// Distributed under the terms of the MIT license
// Test case submitted to project by https://github.com/practicalswift (practicalswift)
// Test case found by fuzzing

struct A{struct d:a{
e B<d:a
struct c<T : a : A >{
let a{{
}}struct S
typealias e
}b}
init(v ( a {
enum S
[]func<T where f
let a {let a{
let a
struct A >{class A{func a{func f: A {{ {func i< >
struct f
func d{func a
}}
init
typealias e(
{
class b=c<d:T{
struct B
enum S< >
var e: f {func a{struct Q<d
e ")
B?
if true{{
var _=b:a
vs dwhere S< >
sct S
let b:a{struct B<T where g.d:e:d{
a{
}}struct f: f {if
sct S
func j.d
struct Q<T where f: C {func j.d} Int] g : A {struct S
e "){func j
class A {
var P{< }}enum a<T where g:Int a
func f=a<d{struct Q<T where g.j
struct f<T where g:a{struct Q{{func j
}}func f
var f{func j,f
struct Q{
var _=e(
if true{
{}protocol a{
class A{var P{func j,f: C {
let b{struct A{func j,f
var _=true as S<T=true as S
struct f<T{func d{struct c<T{< >
protocol P{struct c<b:a
struct c<func f: A{struct Q<T{func d} Int] g : A{class A {
e "){
let b}class A{
protocol P{struct B<T where g:N{if
enum S< }}enum a<T where g:Int a
class A {struct B<T where T=e: a }class k:a{
var e
enum S<T : C {
func f=e
func j,f
protocol P{{
func i< }}enum a<T where g:Int a
typealias d:T{
}
class A{
var b=true as S<T where T{
e B?
var _=true as S<T{{
a{class A{
e B
let a<T{class B?
typealias d} Int] g mb:d} Int] g mb:a{struct c<T{var e(}protocol P{struct B<T where g:a{{
[]func<T where T{
var f=true as S
>
B
func j,f<T{
Void
func d} Int] g mb:A{func j,f{var b{
struct A{
func d:a
Void
var e
struct f=b:a<T : A {
class k:d} Int] g mb:a{
Void
var e
enum S
typealias e: f {
struct g mb:d{
}
enum e
}{{struct c<T where T{{ {
vs dwhere S<T : Int = ()
var _=e
{b {class A{}class {{
func d{class A{
sct S
let a : a : a : a : a : C {class A{
func i(
Q{struct Q{< >
let a=b{
func j
enum S<T : a : Int = (
}protocol A{}}
struct f<T{
class A{b {struct A{
func j,f: a : a : Int = (}
typealias b{}class A{
struct d:a
class A {func a{if
}
}func j.d
init(v ( a : C {}}{
if true{struct B<T where g:a
func i(}
let : C {
struct c<T where g.d:struct Q{class B<func f: a }protocol A{var e: A{struct g : C {
{b {
init(}b=Any
B
class A {
class A{}struct d:T{{struct g mb:a
var b{}}protocol A{
}}func f=b{
class A{struct c<T where h:e
typealias e
