// 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

}
protocol P{func g:{
}
{
import n}
struct c<T: NSManagedObject {
let end = nil
let end = nil
protocol A{enum S<H
for c {
}
protocol c<T where g<T: Array) {
struct c{
class A"\(}
class a
typealias e:
var e:S{
class A : {class A{
}
func f A{
protocol A{let:A?typealias e:a
class A{
<T. : {
<d where f<T where g<T A : Array) {
class A? {
struct c<T where g: {
let s=[]if true{
struct D {
class
struct S{r
let a init(}
class a
}
struct Q{
let
func a{
}
}
}
class A?typealias b<H.b:a<T f<T where k.b:A
let a {
struct Q{
}
protocol P{protocol a {
}
protocol A{
enum S<T where g:a
import n}
protocol a {
typealias e:a{
{func a<T:
protocol P{
class A{
class func a
struct S{
var A?typealias b{protocol A
class a{
let a {
struct S<T: a {
func f:{let:b{
}
protocol a {{
}
class A"\(t
var _=Void{
}
class func f A< T where T: Array) {
let s=Void{
for c {let:A? {
protocol A? = A{
class A? {
class func f A{
var A{
let:a{typealias e
let b : NSManagedObject {
class
{
class A : <b<H. : {
let a {
enum S<T where f<T where k. : b(t
}
let:A{
}
for c {
class A{
let b : <T:
protocol A{
struct S
var e:ExtensibleCollectionType
protocol a {let:a{let:a
protocol a {r
class S<d where H.b
struct S<T where g:
}
<T where g: {
protocol P{
protocol A< T where T: NSManagedObject {enum S{
func f A
< T where k.b:a{
var _=Void{
var e: d where T:{
struct c<T where f<H : <H:A:a
<T where f: {
class func b<T. : a {
func a=[]if true{class a=Void{struct c<H : {
func a{
let end = nil
{
struct S{let
class A{
{
let d:a
class C<d = A
<T where H. : NSManagedObject {
class a
struct S
class C<b(T:
protocol A{
struct S
protocol A{
{class C<H:e
func a<b
func a
{enum :a=[]if true{protocol A? {
struct D {
let a init(t
var b : a {
}
}
func a=[]if true{
let b {
let s=[
var e
func a
protocol a {
func a
enum S<d = {
protocol A{
}
{
let d:S<T where f<d = {
let
{
typealias b
var e
for c {
struct Q{r
}class a{
let
class A{
func a{let
}
protocol P{class C<T: d where f<T: <d where f: d = {
}
func f A
class
{
let
}
class a
class A :
}
var a{
class a{
var _=Void{
class :S<H
}
var e
var b {
import n}
protocol A{
func a{r
class a<T where g:A{let:A{
}
let a {
protocol P{
let s=[]if true{
}
let a {class A"\(}
protocol a {
struct
