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

let a{
let t: B(T:A{
}}
func a{
}
func a{
class B<D> < {{var b
case A? {
typealias e
class A}
let a{
func b="""[1
case B<D> {}protocol A
}}
}}
func b{{}}struct S<T where g:A{var _=a<c
func b{
}}
}
}
var d = B<T where T)struct c:A{
for b in < {extension}
protocol a
}
var d< {
protocol A{
class {struct Q{extension}
class A()struct S<T where g: A}
( )
typealias e=a
let:A:e
let ceturn { e:A(T{{{class A{
struct c< {}
for b in < A{{
class a
for
enum E<T where T:e
class B<T where T> {
case A? {
( )
{
class B<T{{
}
deinit {
for b in < {
class A:e=g: d
class a{
case A:B{}
case A? {
func d{
}
case B
}
for b in < {
let t: A? {let t: String {}
}}}
}
}let b
for
}}func T{
struct Q<T:A:T{}
case A:A? {
func i()
class c<T{class a
for b in < { e{func d{{{}}struct S<T where g:A{var _=a<c
}let h = 0
}protocol P{func b{}}
func d<T where T{func T>:A:A{
}
struct Q{
let:A? {{
}enum E<T)
}
case A{}func b="""""[1
}
}}}enum E<T where T)
protocol c< { e
case B<T where a
class {
struct c
let h = 0
struct Q{var b
{
class b{
}}func b{{{}
{{}}struct S<T where g:A{var _=a<c
class c
let:e, ?
class d{{let a{{var b{class B<T> {class A(Int)
}}
var b=r(Int)()()struct S<T where a{var b{
class a{
let b{
let a {
struct c< {var d = 0
enum e:T> {{}func b=g: d{
let a {class a:{}
{
var d{{}}struct S<T where g:A{var _=a<c
class {}enum e{}}protocol c< {
}}func b
}
let a {{
struct Q<T where g>:A{
{
( )
func i(T{
}}
}
protocol P{
class a{func a
enum E<T where g: d< { e:d<T where g>struct Q{
case B{{}
struct Q<T where g>struct S<T where T> < A{class A{typealias e
func b
va d="[1
class a
struct Q{
let a{
}
class B<T where T> {class B<T where a:e=a{
{}
let a {typealias e:T{
struct S<T where a
struct Q{extension}
typealias e, ?
class A{{var b{
}}
class a
}}func b=a
for b in < {var d = 0
typealias F = 1)()()struct Q<T : String {
( ){
}
func b
va d{func d<T where T> {{class A}}
class B{class A
{{{
case B{{class b
}
class {{}}struct S<T where g:A{var _=a<c
case A
struct c<T : B<T where a:A{{}}struct S<T where g:A{var _=a<c
enum E<T:T{
func b{{
let b=g: B<T where T{
class a
typealias e
class B<T : A? {{class B()
for
class A
func T> {
protocol c<T where T:{}
case B<T>struct c< {
class a{class B<D> < {}
}
{
}
protocol
