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

var b {
func e
func f{
"
class
println( 1 )
class
}}protocol B : a {
}}
}}
let end = j
protocol B : a {
class func a<f{
class b {
let f = B, leng
var d = j
}protocol B : e = B<d typealias e : e
let end = B
println 1 )
struct c {
typealias A}
class
let a {
}}protocol b
func b<T where k.a<T
case c:b
class
var b = [Void{
let f = [ {
deinit {
class B, leng
class
class
func e.b {
}}typealias f = a<T> String {
0.b {
let end = 0 as a
typealias e : e
{
{{
}class a {{
let end = 0 as a<T>: b where B {
let a {
protocol a {
func a
class A {
var d where B : B<T{
protocol a {
struct A<d<T> (v: d<f
}typealias e : a {
class
}}
func f:b<d<T
func a<d<T>: B, leng
struct Q<T>: b = [Void{}extension String{
case c,
}extension String{
typealias B<d where B {
typealias e = [Void{
typealias e?)
case c,
func b:T>
struct A {
func e
let f = 0 as a
case ,
class
func b
func b
let a
class A {
}
var d where B : e
struct A {
protocol B : b = 0 as a
func a(v: d: d
}}func e{
deinit {
protocol a
protocol b
"
case c,
{
case c,
let f : d<T>:T> (v: e = a
{return}
typealias e : a {
println( 1 )
struct A<T where k.h
var d where B : d<d where B : b {struct A
struct A {
i>: e.h
case ,
let a {
let f = B? {
typealias e : e.b {
protocol a {
func b:BooleanType
class B : B<d<d = [ {struct Q<T>
let end = []
}}}class B, leng
{
case c,
}}}typealias e : e.b = [ {
func a
case ,
let end = [ {
{}
class B, leng
case ,
func b<T>: B? {
case c,
0.h
case c,
{{
let end = [Void{
func b}
let f = j
class B<b
class B
func a<T>: a {
typealias e
class B
let end = j
typealias e = [Void{
case c,
let a {
let end = j
struct A<T> (v: e?)
class
func e
protocol B : b { func e(v: a {
struct Q<d<T> (v: e.b {
class
b {
protocol a {
{
class b<d<d where k.b { func a<b
class
case c,
class A {}
typealias
