// RUN: not %target-swift-frontend %s -parse
// 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 S<T where I.d
}}}
(A.c}}}struct Q{
protocol A{
struct B<T where T:A}
{enum S<T where h:b
func f
}protocol a{
return[T:d
{
func a{
}
struct B<T where I.c
}}}
var d>:A<g:a{
}}
{{
{
{
func j}
var d:d{{{struct E{class A{{}let a=[[protocol
func b
}{{{enum k{{
func f
""1
{
struct S
class a{{{func e=e{class b
if true{}}
if true{class D{}}
}protocol a}protocol A.d
struct B:c
{}
let a
}}
struct E{{
(A}
struct S<T where B:BooleanType w
func j}}{
}}
1
}}}
if true{class a{
}protocol a{
{{{
struct B:a{{{
class
class b{{enum k{
{var d{func e
struct S<T where g:a{class i
}}}
}
class a{enum S
""
return[T->{
{
class A{func e
}}class a{
struct B:A.c
class b<T where I.c:d
"1
let a{{}protocol a{{
{{class a<T where T:c}}
class a
{typealias d{
}}
class i
struct E{
class a{func f
}}}
{
struct E{a{}struct S
}}}
class b
{}
class b{
{class a{
}}}struct B:a{var d{
{}
{class i
{
}
}
}}}protocol A.c
{{class D{func f
class
return[T:A{a{class d>{
protocol a
{enum S<T where T:a
func a{{
{}{enum S<T where h:A{func f
struct B:d{{var d
(((((((A<T where T:A<T:BooleanType w
{}class D{
{{{
struct B<g:A.c
struct B:d{class A {}}{func e
}}{func e{
{{
{{
(A<T where g:d:b
}protocol a
func a{
var d{func b{{{{
struct B<T where I.c:a<T where B:a
struct E{class D{{}
return[T:a<T where B<T where h}protocol A.d.c
{
{class a
func e{
class a{
class
}
{}struct E{
{{{func e
}print
class b {typealias e
}}{}print
}}protocol A.d<T:a{
{
{{class a{{typealias d.c}}}protocol a{class b{
{{
{struct E{class A{{}let a=[[protocol
{
{typealias e
}
return[T:a
class
var d>:a{func e
(A{func j}
{{var d{
""
func b{
{
}}
{class A {
(A{{struct E{class A{{}let a=[[protocol
func e{
{{
}}}print
let a}struct E{
}}protocol d
if true{
if true{{}struct E{{
(((A{{class b typealias e
struct E{
{{
{{
(A}typealias e
struct E{class a{
{class D{class D{
{{{class i
return[T:b{{class d>:A.c:a
((A<T where T:a
}extension h}print
{{{var d<T where g:A}
class A.c
}typealias e
class d{
class d.c:a
class a
}}
}}
struct B<T where B<T where k{{{class A {{{
struct E{{}
{enum S<T where h
