text:
// Code generated by ffjson <https://github.com/pquerna/ffjson>. DO NOT EDIT.
// source: types.go

package api

import (
	"bytes"
	"encoding/json"
	"fmt"
	fflib "github.com/pquerna/ffjson/fflib/v1"
)

// MarshalJSON marshal bytes to json - template
func (j *ResponseError) MarshalJSON() ([]byte, error) {
	var buf fflib.Buffer
	if j == nil {
		buf.WriteString("null")
		return buf.Bytes(), nil
	}
	err := j.MarshalJSONBuf(&buf)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

// MarshalJSONBuf marshal buff to json - template
func (j *ResponseError) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
	if j == nil {
		buf.WriteString("null")
		return nil
	}
	var err error
	var obj []byte
	_ = obj
	_ = err
	buf.WriteString(`{"code":`)
	fflib.FormatBits2(buf, uint64(j.Code), 10, j.Code < 0)
	buf.WriteString(`,"message":`)
	fflib.WriteJsonString(buf, string(j.Message))
	buf.WriteString(`,"data":`)

	{

		err = j.Data.MarshalJSONBuf(buf)
		if err != nil {
			return err
		}

	}
	buf.WriteByte('}')
	return nil
}

const (
	ffjtResponseErrorbase = iota
	ffjtResponseErrornosuchkey

	ffjtResponseErrorCode

	ffjtResponseErrorMessage

	ffjtResponseErrorData
)

var ffjKeyResponseErrorCode = []byte("code")

var ffjKeyResponseErrorMessage = []byte("message")

var ffjKeyResponseErrorData = []byte("data")

// UnmarshalJSON umarshall json - template of ffjson
func (j *ResponseError) UnmarshalJSON(input []byte) error {
	fs := fflib.NewFFLexer(input)
	return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
}

// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
func (j *ResponseError) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
	var err error
	currentKey := ffjtResponseErrorbase
	_ = currentKey
	tok := fflib.FFTok_init
	wantedTok := fflib.FFTok_init

mainparse:
	for {
		tok = fs.Scan()
		//	println(fmt.Sprintf("debug: tok: %v  state: %v", tok, state))
		if tok == fflib.FFTok_error {
			goto tokerror
		}

		switch state {

		case fflib.FFParse_map_start:
			if tok != fflib.FFTok_left_bracket {
				wantedTok = fflib.FFTok_left_bracket
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_key
			continue

		case fflib.FFParse_after_value:
			if tok == fflib.FFTok_comma {
				state = fflib.FFParse_want_key
			} else if tok == fflib.FFTok_right_bracket {
				goto done
			} else {
				wantedTok = fflib.FFTok_comma
				goto wrongtokenerror
			}

		case fflib.FFParse_want_key:
			// json {} ended. goto exit. woo.
			if tok == fflib.FFTok_right_bracket {
				goto done
			}
			if tok != fflib.FFTok_string {
				wantedTok = fflib.FFTok_string
				goto wrongtokenerror
			}

			kn := fs.Output.Bytes()
			if len(kn) <= 0 {
				// "" case. hrm.
				currentKey = ffjtResponseErrornosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			} else {
				switch kn[0] {

				case 'c':

					if bytes.Equal(ffjKeyResponseErrorCode, kn) {
						currentKey = ffjtResponseErrorCode
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'd':

					if bytes.Equal(ffjKeyResponseErrorData, kn) {
						currentKey = ffjtResponseErrorData
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'm':

					if bytes.Equal(ffjKeyResponseErrorMessage, kn) {
						currentKey = ffjtResponseErrorMessage
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorData, kn) {
					currentKey = ffjtResponseErrorData
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.EqualFoldRight(ffjKeyResponseErrorMessage, kn) {
					currentKey = ffjtResponseErrorMessage
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorCode, kn) {
					currentKey = ffjtResponseErrorCode
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				currentKey = ffjtResponseErrornosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			}

		case fflib.FFParse_want_colon:
			if tok != fflib.FFTok_colon {
				wantedTok = fflib.FFTok_colon
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_value
			continue
		case fflib.FFParse_want_value:

			if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
				switch currentKey {

				case ffjtResponseErrorCode:
					goto handle_Code

				case ffjtResponseErrorMessage:
					goto handle_Message

				case ffjtResponseErrorData:
					goto handle_Data

				case ffjtResponseErrornosuchkey:
					err = fs.SkipField(tok)
					if err != nil {
						return fs.WrapErr(err)
					}
					state = fflib.FFParse_after_value
					goto mainparse
				}
			} else {
				goto wantedvalue
			}
		}
	}

handle_Code:

	/* handler: j.Code type=int kind=int quoted=false*/

	{
		if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
			return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok))
		}
	}

	{

		if tok == fflib.FFTok_null {

		} else {

			tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)

			if err != nil {
				return fs.WrapErr(err)
			}

			j.Code = int(tval)

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Message:

	/* handler: j.Message type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.Message = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Data:

	/* handler: j.Data type=api.ResponseErrorData kind=struct quoted=false*/

	{
		if tok == fflib.FFTok_null {

		} else {

			err = j.Data.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
			if err != nil {
				return err
			}
		}
		state = fflib.FFParse_after_value
	}

	state = fflib.FFParse_after_value
	goto mainparse

wantedvalue:
	return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
wrongtokenerror:
	return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
tokerror:
	if fs.BigError != nil {
		return fs.WrapErr(fs.BigError)
	}
	err = fs.Error.ToError()
	if err != nil {
		return fs.WrapErr(err)
	}
	panic("ffjson-generated: unreachable, please report bug.")
done:

	return nil
}

// MarshalJSON marshal bytes to json - template
func (j *ResponseErrorContext) MarshalJSON() ([]byte, error) {
	var buf fflib.Buffer
	if j == nil {
		buf.WriteString("null")
		return buf.Bytes(), nil
	}
	err := j.MarshalJSONBuf(&buf)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

// MarshalJSONBuf marshal buff to json - template
func (j *ResponseErrorContext) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
	if j == nil {
		buf.WriteString("null")
		return nil
	}
	var err error
	var obj []byte
	_ = obj
	_ = err
	buf.WriteString(`{"level":`)
	fflib.WriteJsonString(buf, string(j.Level))
	buf.WriteString(`,"file":`)
	fflib.WriteJsonString(buf, string(j.File))
	buf.WriteString(`,"line":`)
	fflib.FormatBits2(buf, uint64(j.Line), 10, j.Line < 0)
	buf.WriteString(`,"method":`)
	fflib.WriteJsonString(buf, string(j.Method))
	buf.WriteString(`,"hostname":`)
	fflib.WriteJsonString(buf, string(j.Hostname))
	buf.WriteString(`,"thread_name":`)
	fflib.WriteJsonString(buf, string(j.ThreadName))
	buf.WriteString(`,"timestamp":`)
	fflib.WriteJsonString(buf, string(j.Timestamp))
	buf.WriteByte('}')
	return nil
}

const (
	ffjtResponseErrorContextbase = iota
	ffjtResponseErrorContextnosuchkey

	ffjtResponseErrorContextLevel

	ffjtResponseErrorContextFile

	ffjtResponseErrorContextLine

	ffjtResponseErrorContextMethod

	ffjtResponseErrorContextHostname

	ffjtResponseErrorContextThreadName

	ffjtResponseErrorContextTimestamp
)

var ffjKeyResponseErrorContextLevel = []byte("level")

var ffjKeyResponseErrorContextFile = []byte("file")

var ffjKeyResponseErrorContextLine = []byte("line")

var ffjKeyResponseErrorContextMethod = []byte("method")

var ffjKeyResponseErrorContextHostname = []byte("hostname")

var ffjKeyResponseErrorContextThreadName = []byte("thread_name")

var ffjKeyResponseErrorContextTimestamp = []byte("timestamp")

// UnmarshalJSON umarshall json - template of ffjson
func (j *ResponseErrorContext) UnmarshalJSON(input []byte) error {
	fs := fflib.NewFFLexer(input)
	return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
}

// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
func (j *ResponseErrorContext) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
	var err error
	currentKey := ffjtResponseErrorContextbase
	_ = currentKey
	tok := fflib.FFTok_init
	wantedTok := fflib.FFTok_init

mainparse:
	for {
		tok = fs.Scan()
		//	println(fmt.Sprintf("debug: tok: %v  state: %v", tok, state))
		if tok == fflib.FFTok_error {
			goto tokerror
		}

		switch state {

		case fflib.FFParse_map_start:
			if tok != fflib.FFTok_left_bracket {
				wantedTok = fflib.FFTok_left_bracket
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_key
			continue

		case fflib.FFParse_after_value:
			if tok == fflib.FFTok_comma {
				state = fflib.FFParse_want_key
			} else if tok == fflib.FFTok_right_bracket {
				goto done
			} else {
				wantedTok = fflib.FFTok_comma
				goto wrongtokenerror
			}

		case fflib.FFParse_want_key:
			// json {} ended. goto exit. woo.
			if tok == fflib.FFTok_right_bracket {
				goto done
			}
			if tok != fflib.FFTok_string {
				wantedTok = fflib.FFTok_string
				goto wrongtokenerror
			}

			kn := fs.Output.Bytes()
			if len(kn) <= 0 {
				// "" case. hrm.
				currentKey = ffjtResponseErrorContextnosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			} else {
				switch kn[0] {

				case 'f':

					if bytes.Equal(ffjKeyResponseErrorContextFile, kn) {
						currentKey = ffjtResponseErrorContextFile
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'h':

					if bytes.Equal(ffjKeyResponseErrorContextHostname, kn) {
						currentKey = ffjtResponseErrorContextHostname
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'l':

					if bytes.Equal(ffjKeyResponseErrorContextLevel, kn) {
						currentKey = ffjtResponseErrorContextLevel
						state = fflib.FFParse_want_colon
						goto mainparse

					} else if bytes.Equal(ffjKeyResponseErrorContextLine, kn) {
						currentKey = ffjtResponseErrorContextLine
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'm':

					if bytes.Equal(ffjKeyResponseErrorContextMethod, kn) {
						currentKey = ffjtResponseErrorContextMethod
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 't':

					if bytes.Equal(ffjKeyResponseErrorContextThreadName, kn) {
						currentKey = ffjtResponseErrorContextThreadName
						state = fflib.FFParse_want_colon
						goto mainparse

					} else if bytes.Equal(ffjKeyResponseErrorContextTimestamp, kn) {
						currentKey = ffjtResponseErrorContextTimestamp
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				}

				if fflib.EqualFoldRight(ffjKeyResponseErrorContextTimestamp, kn) {
					currentKey = ffjtResponseErrorContextTimestamp
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.AsciiEqualFold(ffjKeyResponseErrorContextThreadName, kn) {
					currentKey = ffjtResponseErrorContextThreadName
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.EqualFoldRight(ffjKeyResponseErrorContextHostname, kn) {
					currentKey = ffjtResponseErrorContextHostname
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorContextMethod, kn) {
					currentKey = ffjtResponseErrorContextMethod
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorContextLine, kn) {
					currentKey = ffjtResponseErrorContextLine
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorContextFile, kn) {
					currentKey = ffjtResponseErrorContextFile
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorContextLevel, kn) {
					currentKey = ffjtResponseErrorContextLevel
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				currentKey = ffjtResponseErrorContextnosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			}

		case fflib.FFParse_want_colon:
			if tok != fflib.FFTok_colon {
				wantedTok = fflib.FFTok_colon
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_value
			continue
		case fflib.FFParse_want_value:

			if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
				switch currentKey {

				case ffjtResponseErrorContextLevel:
					goto handle_Level

				case ffjtResponseErrorContextFile:
					goto handle_File

				case ffjtResponseErrorContextLine:
					goto handle_Line

				case ffjtResponseErrorContextMethod:
					goto handle_Method

				case ffjtResponseErrorContextHostname:
					goto handle_Hostname

				case ffjtResponseErrorContextThreadName:
					goto handle_ThreadName

				case ffjtResponseErrorContextTimestamp:
					goto handle_Timestamp

				case ffjtResponseErrorContextnosuchkey:
					err = fs.SkipField(tok)
					if err != nil {
						return fs.WrapErr(err)
					}
					state = fflib.FFParse_after_value
					goto mainparse
				}
			} else {
				goto wantedvalue
			}
		}
	}

handle_Level:

	/* handler: j.Level type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.Level = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_File:

	/* handler: j.File type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.File = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Line:

	/* handler: j.Line type=int kind=int quoted=false*/

	{
		if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
			return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok))
		}
	}

	{

		if tok == fflib.FFTok_null {

		} else {

			tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)

			if err != nil {
				return fs.WrapErr(err)
			}

			j.Line = int(tval)

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Method:

	/* handler: j.Method type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.Method = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Hostname:

	/* handler: j.Hostname type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.Hostname = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_ThreadName:

	/* handler: j.ThreadName type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.ThreadName = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Timestamp:

	/* handler: j.Timestamp type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.Timestamp = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

wantedvalue:
	return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
wrongtokenerror:
	return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
tokerror:
	if fs.BigError != nil {
		return fs.WrapErr(fs.BigError)
	}
	err = fs.Error.ToError()
	if err != nil {
		return fs.WrapErr(err)
	}
	panic("ffjson-generated: unreachable, please report bug.")
done:

	return nil
}

// MarshalJSON marshal bytes to json - template
func (j *ResponseErrorData) MarshalJSON() ([]byte, error) {
	var buf fflib.Buffer
	if j == nil {
		buf.WriteString("null")
		return buf.Bytes(), nil
	}
	err := j.MarshalJSONBuf(&buf)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

// MarshalJSONBuf marshal buff to json - template
func (j *ResponseErrorData) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
	if j == nil {
		buf.WriteString("null")
		return nil
	}
	var err error
	var obj []byte
	_ = obj
	_ = err
	buf.WriteString(`{"code":`)
	fflib.FormatBits2(buf, uint64(j.Code), 10, j.Code < 0)
	buf.WriteString(`,"name":`)
	fflib.WriteJsonString(buf, string(j.Name))
	buf.WriteString(`,"message":`)
	fflib.WriteJsonString(buf, string(j.Message))
	buf.WriteString(`,"stack":`)
	if j.Stack != nil {
		buf.WriteString(`[`)
		for i, v := range j.Stack {
			if i != 0 {
				buf.WriteString(`,`)
			}

			{

				err = v.MarshalJSONBuf(buf)
				if err != nil {
					return err
				}

			}
		}
		buf.WriteString(`]`)
	} else {
		buf.WriteString(`null`)
	}
	buf.WriteByte('}')
	return nil
}

const (
	ffjtResponseErrorDatabase = iota
	ffjtResponseErrorDatanosuchkey

	ffjtResponseErrorDataCode

	ffjtResponseErrorDataName

	ffjtResponseErrorDataMessage

	ffjtResponseErrorDataStack
)

var ffjKeyResponseErrorDataCode = []byte("code")

var ffjKeyResponseErrorDataName = []byte("name")

var ffjKeyResponseErrorDataMessage = []byte("message")

var ffjKeyResponseErrorDataStack = []byte("stack")

// UnmarshalJSON umarshall json - template of ffjson
func (j *ResponseErrorData) UnmarshalJSON(input []byte) error {
	fs := fflib.NewFFLexer(input)
	return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
}

// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
func (j *ResponseErrorData) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
	var err error
	currentKey := ffjtResponseErrorDatabase
	_ = currentKey
	tok := fflib.FFTok_init
	wantedTok := fflib.FFTok_init

mainparse:
	for {
		tok = fs.Scan()
		//	println(fmt.Sprintf("debug: tok: %v  state: %v", tok, state))
		if tok == fflib.FFTok_error {
			goto tokerror
		}

		switch state {

		case fflib.FFParse_map_start:
			if tok != fflib.FFTok_left_bracket {
				wantedTok = fflib.FFTok_left_bracket
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_key
			continue

		case fflib.FFParse_after_value:
			if tok == fflib.FFTok_comma {
				state = fflib.FFParse_want_key
			} else if tok == fflib.FFTok_right_bracket {
				goto done
			} else {
				wantedTok = fflib.FFTok_comma
				goto wrongtokenerror
			}

		case fflib.FFParse_want_key:
			// json {} ended. goto exit. woo.
			if tok == fflib.FFTok_right_bracket {
				goto done
			}
			if tok != fflib.FFTok_string {
				wantedTok = fflib.FFTok_string
				goto wrongtokenerror
			}

			kn := fs.Output.Bytes()
			if len(kn) <= 0 {
				// "" case. hrm.
				currentKey = ffjtResponseErrorDatanosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			} else {
				switch kn[0] {

				case 'c':

					if bytes.Equal(ffjKeyResponseErrorDataCode, kn) {
						currentKey = ffjtResponseErrorDataCode
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'm':

					if bytes.Equal(ffjKeyResponseErrorDataMessage, kn) {
						currentKey = ffjtResponseErrorDataMessage
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'n':

					if bytes.Equal(ffjKeyResponseErrorDataName, kn) {
						currentKey = ffjtResponseErrorDataName
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 's':

					if bytes.Equal(ffjKeyResponseErrorDataStack, kn) {
						currentKey = ffjtResponseErrorDataStack
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				}

				if fflib.EqualFoldRight(ffjKeyResponseErrorDataStack, kn) {
					currentKey = ffjtResponseErrorDataStack
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.EqualFoldRight(ffjKeyResponseErrorDataMessage, kn) {
					currentKey = ffjtResponseErrorDataMessage
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorDataName, kn) {
					currentKey = ffjtResponseErrorDataName
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorDataCode, kn) {
					currentKey = ffjtResponseErrorDataCode
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				currentKey = ffjtResponseErrorDatanosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			}

		case fflib.FFParse_want_colon:
			if tok != fflib.FFTok_colon {
				wantedTok = fflib.FFTok_colon
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_value
			continue
		case fflib.FFParse_want_value:

			if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
				switch currentKey {

				case ffjtResponseErrorDataCode:
					goto handle_Code

				case ffjtResponseErrorDataName:
					goto handle_Name

				case ffjtResponseErrorDataMessage:
					goto handle_Message

				case ffjtResponseErrorDataStack:
					goto handle_Stack

				case ffjtResponseErrorDatanosuchkey:
					err = fs.SkipField(tok)
					if err != nil {
						return fs.WrapErr(err)
					}
					state = fflib.FFParse_after_value
					goto mainparse
				}
			} else {
				goto wantedvalue
			}
		}
	}

handle_Code:

	/* handler: j.Code type=int kind=int quoted=false*/

	{
		if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
			return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok))
		}
	}

	{

		if tok == fflib.FFTok_null {

		} else {

			tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)

			if err != nil {
				return fs.WrapErr(err)
			}

			j.Code = int(tval)

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Name:

	/* handler: j.Name type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.Name = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Message:

	/* handler: j.Message type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.Message = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Stack:

	/* handler: j.Stack type=[]api.ResponseErrorStack kind=slice quoted=false*/

	{

		{
			if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok))
			}
		}

		if tok == fflib.FFTok_null {
			j.Stack = nil
		} else {

			j.Stack = []ResponseErrorStack{}

			wantVal := true

			for {

				var tmpJStack ResponseErrorStack

				tok = fs.Scan()
				if tok == fflib.FFTok_error {
					goto tokerror
				}
				if tok == fflib.FFTok_right_brace {
					break
				}

				if tok == fflib.FFTok_comma {
					if wantVal == true {
						// TODO(pquerna): this isn't an ideal error message, this handles
						// things like [,,,] as an array value.
						return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
					}
					continue
				} else {
					wantVal = true
				}

				/* handler: tmpJStack type=api.ResponseErrorStack kind=struct quoted=false*/

				{
					if tok == fflib.FFTok_null {

					} else {

						err = tmpJStack.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
						if err != nil {
							return err
						}
					}
					state = fflib.FFParse_after_value
				}

				j.Stack = append(j.Stack, tmpJStack)

				wantVal = false
			}
		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

wantedvalue:
	return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
wrongtokenerror:
	return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
tokerror:
	if fs.BigError != nil {
		return fs.WrapErr(fs.BigError)
	}
	err = fs.Error.ToError()
	if err != nil {
		return fs.WrapErr(err)
	}
	panic("ffjson-generated: unreachable, please report bug.")
done:

	return nil
}

// MarshalJSON marshal bytes to json - template
func (j *ResponseErrorStack) MarshalJSON() ([]byte, error) {
	var buf fflib.Buffer
	if j == nil {
		buf.WriteString("null")
		return buf.Bytes(), nil
	}
	err := j.MarshalJSONBuf(&buf)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

// MarshalJSONBuf marshal buff to json - template
func (j *ResponseErrorStack) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
	if j == nil {
		buf.WriteString("null")
		return nil
	}
	var err error
	var obj []byte
	_ = obj
	_ = err
	buf.WriteString(`{"context":`)

	{

		err = j.Context.MarshalJSONBuf(buf)
		if err != nil {
			return err
		}

	}
	buf.WriteString(`,"format":`)
	fflib.WriteJsonString(buf, string(j.Format))
	buf.WriteString(`,"data":`)
	/* Interface types must use runtime reflection. type=interface {} kind=interface */
	err = buf.Encode(j.Data)
	if err != nil {
		return err
	}
	buf.WriteByte('}')
	return nil
}

const (
	ffjtResponseErrorStackbase = iota
	ffjtResponseErrorStacknosuchkey

	ffjtResponseErrorStackContext

	ffjtResponseErrorStackFormat

	ffjtResponseErrorStackData
)

var ffjKeyResponseErrorStackContext = []byte("context")

var ffjKeyResponseErrorStackFormat = []byte("format")

var ffjKeyResponseErrorStackData = []byte("data")

// UnmarshalJSON umarshall json - template of ffjson
func (j *ResponseErrorStack) UnmarshalJSON(input []byte) error {
	fs := fflib.NewFFLexer(input)
	return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
}

// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
func (j *ResponseErrorStack) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
	var err error
	currentKey := ffjtResponseErrorStackbase
	_ = currentKey
	tok := fflib.FFTok_init
	wantedTok := fflib.FFTok_init

mainparse:
	for {
		tok = fs.Scan()
		//	println(fmt.Sprintf("debug: tok: %v  state: %v", tok, state))
		if tok == fflib.FFTok_error {
			goto tokerror
		}

		switch state {

		case fflib.FFParse_map_start:
			if tok != fflib.FFTok_left_bracket {
				wantedTok = fflib.FFTok_left_bracket
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_key
			continue

		case fflib.FFParse_after_value:
			if tok == fflib.FFTok_comma {
				state = fflib.FFParse_want_key
			} else if tok == fflib.FFTok_right_bracket {
				goto done
			} else {
				wantedTok = fflib.FFTok_comma
				goto wrongtokenerror
			}

		case fflib.FFParse_want_key:
			// json {} ended. goto exit. woo.
			if tok == fflib.FFTok_right_bracket {
				goto done
			}
			if tok != fflib.FFTok_string {
				wantedTok = fflib.FFTok_string
				goto wrongtokenerror
			}

			kn := fs.Output.Bytes()
			if len(kn) <= 0 {
				// "" case. hrm.
				currentKey = ffjtResponseErrorStacknosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			} else {
				switch kn[0] {

				case 'c':

					if bytes.Equal(ffjKeyResponseErrorStackContext, kn) {
						currentKey = ffjtResponseErrorStackContext
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'd':

					if bytes.Equal(ffjKeyResponseErrorStackData, kn) {
						currentKey = ffjtResponseErrorStackData
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'f':

					if bytes.Equal(ffjKeyResponseErrorStackFormat, kn) {
						currentKey = ffjtResponseErrorStackFormat
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorStackData, kn) {
					currentKey = ffjtResponseErrorStackData
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorStackFormat, kn) {
					currentKey = ffjtResponseErrorStackFormat
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyResponseErrorStackContext, kn) {
					currentKey = ffjtResponseErrorStackContext
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				currentKey = ffjtResponseErrorStacknosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			}

		case fflib.FFParse_want_colon:
			if tok != fflib.FFTok_colon {
				wantedTok = fflib.FFTok_colon
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_value
			continue
		case fflib.FFParse_want_value:

			if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
				switch currentKey {

				case ffjtResponseErrorStackContext:
					goto handle_Context

				case ffjtResponseErrorStackFormat:
					goto handle_Format

				case ffjtResponseErrorStackData:
					goto handle_Data

				case ffjtResponseErrorStacknosuchkey:
					err = fs.SkipField(tok)
					if err != nil {
						return fs.WrapErr(err)
					}
					state = fflib.FFParse_after_value
					goto mainparse
				}
			} else {
				goto wantedvalue
			}
		}
	}

handle_Context:

	/* handler: j.Context type=api.ResponseErrorContext kind=struct quoted=false*/

	{
		if tok == fflib.FFTok_null {

		} else {

			err = j.Context.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
			if err != nil {
				return err
			}
		}
		state = fflib.FFParse_after_value
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Format:

	/* handler: j.Format type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.Format = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Data:

	/* handler: j.Data type=interface {} kind=interface quoted=false*/

	{
		/* Falling back. type=interface {} kind=interface */
		tbuf, err := fs.CaptureField(tok)
		if err != nil {
			return fs.WrapErr(err)
		}

		err = json.Unmarshal(tbuf, &j.Data)
		if err != nil {
			return fs.WrapErr(err)
		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

wantedvalue:
	return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
wrongtokenerror:
	return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
tokerror:
	if fs.BigError != nil {
		return fs.WrapErr(fs.BigError)
	}
	err = fs.Error.ToError()
	if err != nil {
		return fs.WrapErr(err)
	}
	panic("ffjson-generated: unreachable, please report bug.")
done:

	return nil
}

// MarshalJSON marshal bytes to json - template
func (j *rpcResponse) MarshalJSON() ([]byte, error) {
	var buf fflib.Buffer
	if j == nil {
		buf.WriteString("null")
		return buf.Bytes(), nil
	}
	err := j.MarshalJSONBuf(&buf)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

// MarshalJSONBuf marshal buff to json - template
func (j *rpcResponse) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
	if j == nil {
		buf.WriteString("null")
		return nil
	}
	var err error
	var obj []byte
	_ = obj
	_ = err
	buf.WriteString(`{ "id":`)
	fflib.FormatBits2(buf, uint64(j.ID), 10, false)
	buf.WriteByte(',')
	if j.Result != nil {
		if true {
			buf.WriteString(`"result":`)

			{

				obj, err = j.Result.MarshalJSON()
				if err != nil {
					return err
				}
				buf.Write(obj)

			}
			buf.WriteByte(',')
		}
	}
	if j.Error != nil {
		if true {
			buf.WriteString(`"error":`)

			{

				err = j.Error.MarshalJSONBuf(buf)
				if err != nil {
					return err
				}

			}
			buf.WriteByte(',')
		}
	}
	buf.Rewind(1)
	buf.WriteByte('}')
	return nil
}

const (
	ffjtrpcResponsebase = iota
	ffjtrpcResponsenosuchkey

	ffjtrpcResponseID

	ffjtrpcResponseResult

	ffjtrpcResponseError
)

var ffjKeyrpcResponseID = []byte("id")

var ffjKeyrpcResponseResult = []byte("result")

var ffjKeyrpcResponseError = []byte("error")

// UnmarshalJSON umarshall json - template of ffjson
func (j *rpcResponse) UnmarshalJSON(input []byte) error {
	fs := fflib.NewFFLexer(input)
	return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
}

// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
func (j *rpcResponse) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
	var err error
	currentKey := ffjtrpcResponsebase
	_ = currentKey
	tok := fflib.FFTok_init
	wantedTok := fflib.FFTok_init

mainparse:
	for {
		tok = fs.Scan()
		//	println(fmt.Sprintf("debug: tok: %v  state: %v", tok, state))
		if tok == fflib.FFTok_error {
			goto tokerror
		}

		switch state {

		case fflib.FFParse_map_start:
			if tok != fflib.FFTok_left_bracket {
				wantedTok = fflib.FFTok_left_bracket
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_key
			continue

		case fflib.FFParse_after_value:
			if tok == fflib.FFTok_comma {
				state = fflib.FFParse_want_key
			} else if tok == fflib.FFTok_right_bracket {
				goto done
			} else {
				wantedTok = fflib.FFTok_comma
				goto wrongtokenerror
			}

		case fflib.FFParse_want_key:
			// json {} ended. goto exit. woo.
			if tok == fflib.FFTok_right_bracket {
				goto done
			}
			if tok != fflib.FFTok_string {
				wantedTok = fflib.FFTok_string
				goto wrongtokenerror
			}

			kn := fs.Output.Bytes()
			if len(kn) <= 0 {
				// "" case. hrm.
				currentKey = ffjtrpcResponsenosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			} else {
				switch kn[0] {

				case 'e':

					if bytes.Equal(ffjKeyrpcResponseError, kn) {
						currentKey = ffjtrpcResponseError
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'i':

					if bytes.Equal(ffjKeyrpcResponseID, kn) {
						currentKey = ffjtrpcResponseID
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'r':

					if bytes.Equal(ffjKeyrpcResponseResult, kn) {
						currentKey = ffjtrpcResponseResult
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				}

				if fflib.SimpleLetterEqualFold(ffjKeyrpcResponseError, kn) {
					currentKey = ffjtrpcResponseError
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.EqualFoldRight(ffjKeyrpcResponseResult, kn) {
					currentKey = ffjtrpcResponseResult
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyrpcResponseID, kn) {
					currentKey = ffjtrpcResponseID
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				currentKey = ffjtrpcResponsenosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			}

		case fflib.FFParse_want_colon:
			if tok != fflib.FFTok_colon {
				wantedTok = fflib.FFTok_colon
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_value
			continue
		case fflib.FFParse_want_value:

			if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
				switch currentKey {

				case ffjtrpcResponseID:
					goto handle_ID

				case ffjtrpcResponseResult:
					goto handle_Result

				case ffjtrpcResponseError:
					goto handle_Error

				case ffjtrpcResponsenosuchkey:
					err = fs.SkipField(tok)
					if err != nil {
						return fs.WrapErr(err)
					}
					state = fflib.FFParse_after_value
					goto mainparse
				}
			} else {
				goto wantedvalue
			}
		}
	}

handle_ID:

	/* handler: j.ID type=uint64 kind=uint64 quoted=false*/

	{
		if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
			return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
		}
	}

	{

		if tok == fflib.FFTok_null {

		} else {

			tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)

			if err != nil {
				return fs.WrapErr(err)
			}

			j.ID = uint64(tval)

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Result:

	/* handler: j.Result type=json.RawMessage kind=slice quoted=false*/

	{
		if tok == fflib.FFTok_null {

			j.Result = nil

		} else {

			tbuf, err := fs.CaptureField(tok)
			if err != nil {
				return fs.WrapErr(err)
			}

			if j.Result == nil {
				j.Result = new(json.RawMessage)
			}

			err = j.Result.UnmarshalJSON(tbuf)
			if err != nil {
				return fs.WrapErr(err)
			}
		}
		state = fflib.FFParse_after_value
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Error:

	/* handler: j.Error type=api.ResponseError kind=struct quoted=false*/

	{
		if tok == fflib.FFTok_null {

			j.Error = nil

		} else {

			if j.Error == nil {
				j.Error = new(ResponseError)
			}

			err = j.Error.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
			if err != nil {
				return err
			}
		}
		state = fflib.FFParse_after_value
	}

	state = fflib.FFParse_after_value
	goto mainparse

wantedvalue:
	return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
wrongtokenerror:
	return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
tokerror:
	if fs.BigError != nil {
		return fs.WrapErr(fs.BigError)
	}
	err = fs.Error.ToError()
	if err != nil {
		return fs.WrapErr(err)
	}
	panic("ffjson-generated: unreachable, please report bug.")
done:

	return nil
}

// MarshalJSON marshal bytes to json - template
func (j *rpcResponseString) MarshalJSON() ([]byte, error) {
	var buf fflib.Buffer
	if j == nil {
		buf.WriteString("null")
		return buf.Bytes(), nil
	}
	err := j.MarshalJSONBuf(&buf)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

// MarshalJSONBuf marshal buff to json - template
func (j *rpcResponseString) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
	if j == nil {
		buf.WriteString("null")
		return nil
	}
	var err error
	var obj []byte
	_ = obj
	_ = err
	buf.WriteString(`{ "id":`)
	fflib.WriteJsonString(buf, string(j.ID))
	buf.WriteByte(',')
	if j.Result != nil {
		if true {
			buf.WriteString(`"result":`)

			{

				obj, err = j.Result.MarshalJSON()
				if err != nil {
					return err
				}
				buf.Write(obj)

			}
			buf.WriteByte(',')
		}
	}
	if j.Error != nil {
		if true {
			buf.WriteString(`"error":`)

			{

				err = j.Error.MarshalJSONBuf(buf)
				if err != nil {
					return err
				}

			}
			buf.WriteByte(',')
		}
	}
	buf.Rewind(1)
	buf.WriteByte('}')
	return nil
}

const (
	ffjtrpcResponseStringbase = iota
	ffjtrpcResponseStringnosuchkey

	ffjtrpcResponseStringID

	ffjtrpcResponseStringResult

	ffjtrpcResponseStringError
)

var ffjKeyrpcResponseStringID = []byte("id")

var ffjKeyrpcResponseStringResult = []byte("result")

var ffjKeyrpcResponseStringError = []byte("error")

// UnmarshalJSON umarshall json - template of ffjson
func (j *rpcResponseString) UnmarshalJSON(input []byte) error {
	fs := fflib.NewFFLexer(input)
	return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
}

// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
func (j *rpcResponseString) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
	var err error
	currentKey := ffjtrpcResponseStringbase
	_ = currentKey
	tok := fflib.FFTok_init
	wantedTok := fflib.FFTok_init

mainparse:
	for {
		tok = fs.Scan()
		//	println(fmt.Sprintf("debug: tok: %v  state: %v", tok, state))
		if tok == fflib.FFTok_error {
			goto tokerror
		}

		switch state {

		case fflib.FFParse_map_start:
			if tok != fflib.FFTok_left_bracket {
				wantedTok = fflib.FFTok_left_bracket
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_key
			continue

		case fflib.FFParse_after_value:
			if tok == fflib.FFTok_comma {
				state = fflib.FFParse_want_key
			} else if tok == fflib.FFTok_right_bracket {
				goto done
			} else {
				wantedTok = fflib.FFTok_comma
				goto wrongtokenerror
			}

		case fflib.FFParse_want_key:
			// json {} ended. goto exit. woo.
			if tok == fflib.FFTok_right_bracket {
				goto done
			}
			if tok != fflib.FFTok_string {
				wantedTok = fflib.FFTok_string
				goto wrongtokenerror
			}

			kn := fs.Output.Bytes()
			if len(kn) <= 0 {
				// "" case. hrm.
				currentKey = ffjtrpcResponseStringnosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			} else {
				switch kn[0] {

				case 'e':

					if bytes.Equal(ffjKeyrpcResponseStringError, kn) {
						currentKey = ffjtrpcResponseStringError
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'i':

					if bytes.Equal(ffjKeyrpcResponseStringID, kn) {
						currentKey = ffjtrpcResponseStringID
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'r':

					if bytes.Equal(ffjKeyrpcResponseStringResult, kn) {
						currentKey = ffjtrpcResponseStringResult
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				}

				if fflib.SimpleLetterEqualFold(ffjKeyrpcResponseStringError, kn) {
					currentKey = ffjtrpcResponseStringError
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.EqualFoldRight(ffjKeyrpcResponseStringResult, kn) {
					currentKey = ffjtrpcResponseStringResult
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyrpcResponseStringID, kn) {
					currentKey = ffjtrpcResponseStringID
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				currentKey = ffjtrpcResponseStringnosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			}

		case fflib.FFParse_want_colon:
			if tok != fflib.FFTok_colon {
				wantedTok = fflib.FFTok_colon
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_value
			continue
		case fflib.FFParse_want_value:

			if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
				switch currentKey {

				case ffjtrpcResponseStringID:
					goto handle_ID

				case ffjtrpcResponseStringResult:
					goto handle_Result

				case ffjtrpcResponseStringError:
					goto handle_Error

				case ffjtrpcResponseStringnosuchkey:
					err = fs.SkipField(tok)
					if err != nil {
						return fs.WrapErr(err)
					}
					state = fflib.FFParse_after_value
					goto mainparse
				}
			} else {
				goto wantedvalue
			}
		}
	}

handle_ID:

	/* handler: j.ID type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.ID = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Result:

	/* handler: j.Result type=json.RawMessage kind=slice quoted=false*/

	{
		if tok == fflib.FFTok_null {

			j.Result = nil

		} else {

			tbuf, err := fs.CaptureField(tok)
			if err != nil {
				return fs.WrapErr(err)
			}

			if j.Result == nil {
				j.Result = new(json.RawMessage)
			}

			err = j.Result.UnmarshalJSON(tbuf)
			if err != nil {
				return fs.WrapErr(err)
			}
		}
		state = fflib.FFParse_after_value
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Error:

	/* handler: j.Error type=api.ResponseError kind=struct quoted=false*/

	{
		if tok == fflib.FFTok_null {

			j.Error = nil

		} else {

			if j.Error == nil {
				j.Error = new(ResponseError)
			}

			err = j.Error.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
			if err != nil {
				return err
			}
		}
		state = fflib.FFParse_after_value
	}

	state = fflib.FFParse_after_value
	goto mainparse

wantedvalue:
	return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
wrongtokenerror:
	return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
tokerror:
	if fs.BigError != nil {
		return fs.WrapErr(fs.BigError)
	}
	err = fs.Error.ToError()
	if err != nil {
		return fs.WrapErr(err)
	}
	panic("ffjson-generated: unreachable, please report bug.")
done:

	return nil
}

// MarshalJSON marshal bytes to json - template
func (j *rpcSubscriptionResponse) MarshalJSON() ([]byte, error) {
	var buf fflib.Buffer
	if j == nil {
		buf.WriteString("null")
		return buf.Bytes(), nil
	}
	err := j.MarshalJSONBuf(&buf)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

// MarshalJSONBuf marshal buff to json - template
func (j *rpcSubscriptionResponse) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
	if j == nil {
		buf.WriteString("null")
		return nil
	}
	var err error
	var obj []byte
	_ = obj
	_ = err
	buf.WriteString(`{"method":`)
	fflib.WriteJsonString(buf, string(j.Method))
	buf.WriteString(`,"params":`)
	if j.Params != nil {
		buf.WriteString(`[`)
		for i, v := range j.Params {
			if i != 0 {
				buf.WriteString(`,`)
			}
			/* Interface types must use runtime reflection. type=interface {} kind=interface */
			err = buf.Encode(v)
			if err != nil {
				return err
			}
		}
		buf.WriteString(`]`)
	} else {
		buf.WriteString(`null`)
	}
	buf.WriteByte('}')
	return nil
}

const (
	ffjtrpcSubscriptionResponsebase = iota
	ffjtrpcSubscriptionResponsenosuchkey

	ffjtrpcSubscriptionResponseMethod

	ffjtrpcSubscriptionResponseParams
)

var ffjKeyrpcSubscriptionResponseMethod = []byte("method")

var ffjKeyrpcSubscriptionResponseParams = []byte("params")

// UnmarshalJSON umarshall json - template of ffjson
func (j *rpcSubscriptionResponse) UnmarshalJSON(input []byte) error {
	fs := fflib.NewFFLexer(input)
	return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
}

// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
func (j *rpcSubscriptionResponse) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
	var err error
	currentKey := ffjtrpcSubscriptionResponsebase
	_ = currentKey
	tok := fflib.FFTok_init
	wantedTok := fflib.FFTok_init

mainparse:
	for {
		tok = fs.Scan()
		//	println(fmt.Sprintf("debug: tok: %v  state: %v", tok, state))
		if tok == fflib.FFTok_error {
			goto tokerror
		}

		switch state {

		case fflib.FFParse_map_start:
			if tok != fflib.FFTok_left_bracket {
				wantedTok = fflib.FFTok_left_bracket
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_key
			continue

		case fflib.FFParse_after_value:
			if tok == fflib.FFTok_comma {
				state = fflib.FFParse_want_key
			} else if tok == fflib.FFTok_right_bracket {
				goto done
			} else {
				wantedTok = fflib.FFTok_comma
				goto wrongtokenerror
			}

		case fflib.FFParse_want_key:
			// json {} ended. goto exit. woo.
			if tok == fflib.FFTok_right_bracket {
				goto done
			}
			if tok != fflib.FFTok_string {
				wantedTok = fflib.FFTok_string
				goto wrongtokenerror
			}

			kn := fs.Output.Bytes()
			if len(kn) <= 0 {
				// "" case. hrm.
				currentKey = ffjtrpcSubscriptionResponsenosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			} else {
				switch kn[0] {

				case 'm':

					if bytes.Equal(ffjKeyrpcSubscriptionResponseMethod, kn) {
						currentKey = ffjtrpcSubscriptionResponseMethod
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				case 'p':

					if bytes.Equal(ffjKeyrpcSubscriptionResponseParams, kn) {
						currentKey = ffjtrpcSubscriptionResponseParams
						state = fflib.FFParse_want_colon
						goto mainparse
					}

				}

				if fflib.EqualFoldRight(ffjKeyrpcSubscriptionResponseParams, kn) {
					currentKey = ffjtrpcSubscriptionResponseParams
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				if fflib.SimpleLetterEqualFold(ffjKeyrpcSubscriptionResponseMethod, kn) {
					currentKey = ffjtrpcSubscriptionResponseMethod
					state = fflib.FFParse_want_colon
					goto mainparse
				}

				currentKey = ffjtrpcSubscriptionResponsenosuchkey
				state = fflib.FFParse_want_colon
				goto mainparse
			}

		case fflib.FFParse_want_colon:
			if tok != fflib.FFTok_colon {
				wantedTok = fflib.FFTok_colon
				goto wrongtokenerror
			}
			state = fflib.FFParse_want_value
			continue
		case fflib.FFParse_want_value:

			if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
				switch currentKey {

				case ffjtrpcSubscriptionResponseMethod:
					goto handle_Method

				case ffjtrpcSubscriptionResponseParams:
					goto handle_Params

				case ffjtrpcSubscriptionResponsenosuchkey:
					err = fs.SkipField(tok)
					if err != nil {
						return fs.WrapErr(err)
					}
					state = fflib.FFParse_after_value
					goto mainparse
				}
			} else {
				goto wantedvalue
			}
		}
	}

handle_Method:

	/* handler: j.Method type=string kind=string quoted=false*/

	{

		{
			if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
			}
		}

		if tok == fflib.FFTok_null {

		} else {

			outBuf := fs.Output.Bytes()

			j.Method = string(string(outBuf))

		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

handle_Params:

	/* handler: j.Params type=[]interface {} kind=slice quoted=false*/

	{

		{
			if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null {
				return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok))
			}
		}

		if tok == fflib.FFTok_null {
			j.Params = nil
		} else {

			j.Params = []interface{}{}

			wantVal := true

			for {

				var tmpJParams interface{}

				tok = fs.Scan()
				if tok == fflib.FFTok_error {
					goto tokerror
				}
				if tok == fflib.FFTok_right_brace {
					break
				}

				if tok == fflib.FFTok_comma {
					if wantVal == true {
						// TODO(pquerna): this isn't an ideal error message, this handles
						// things like [,,,] as an array value.
						return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
					}
					continue
				} else {
					wantVal = true
				}

				/* handler: tmpJParams type=interface {} kind=interface quoted=false*/

				{
					/* Falling back. type=interface {} kind=interface */
					tbuf, err := fs.CaptureField(tok)
					if err != nil {
						return fs.WrapErr(err)
					}

					err = json.Unmarshal(tbuf, &tmpJParams)
					if err != nil {
						return fs.WrapErr(err)
					}
				}

				j.Params = append(j.Params, tmpJParams)

				wantVal = false
			}
		}
	}

	state = fflib.FFParse_after_value
	goto mainparse

wantedvalue:
	return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
wrongtokenerror:
	return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
tokerror:
	if fs.BigError != nil {
		return fs.WrapErr(fs.BigError)
	}
	err = fs.Error.ToError()
	if err != nil {
		return fs.WrapErr(err)
	}
	panic("ffjson-generated: unreachable, please report bug.")
done:

	return nil
}


text:
Q: How can I change the color of an element using a UIBezierPath? First post on stackoverflow so, first and foremost, hello!
I'm trying my hand at Swift for the first time and am working a project and just needed some help on a problem I'm having. I've got a circle using a UIBezierPath that I'd like to change the color of, dynamically. However, when I try to even "hard code" the color, I'm unable to get it to change. I've tried looking here: How to change the color of a UIBezierPath in Swift?, but it didn't answer my question. However, I do see that one answer there does state that a Bezier path has no color. If so, how would I then go about altering the color of the circle going along its path?
Here's the code I'm working with:
    outerCircle.path = UIBezierPath(ovalInRect: CGRect(x: 0.0, y: 0.0, width: frameSize.width, height: frameSize.height)).CGPath
    outerCircle.lineWidth = 8.0
    outerCircle.strokeStart = 0.0
    outerCircle.strokeEnd = 0.45
    outerCircle.lineCap = kCALineCapRound
    outerCircle.fillColor = UIColor.clearColor().CGColor
    outerCircle.strokeColor = UIColor.grayColor().CGColor
    outerCircleView.layer.addSublayer(outerCircle)

    outerCircle.strokeStart = 0.0
    outerCircle.strokeEnd = 1.0

    vibrancyView.contentView.addSubview(outerCircleView)

    innerCircleView.frame.size = frameSize

    let innerCirclePadding: CGFloat = 12
    innerCircle.path = UIBezierPath(ovalInRect: CGRect(x: innerCirclePadding, y: innerCirclePadding, width: frameSize.width - 2*innerCirclePadding, height: frameSize.height - 2*innerCirclePadding)).CGPath
    innerCircle.lineWidth = 4.0
    innerCircle.strokeStart = 0.5
    innerCircle.strokeEnd = 0.9
    innerCircle.lineCap = kCALineCapRound
    innerCircle.fillColor = UIColor.clearColor().CGColor
    innerCircle.strokeColor = UIColor.grayColor().CGColor
    innerCircleView.layer.addSublayer(innerCircle)

Again, I apologize if this is an obvious answer or has already been answered. I appreciate any advice that would help point me in the right direction. Thank you.
UPDATE:  So here's what I tried doing. I changed the fill and stroke colors of both inner and outer circles to green, but I still have clear circles:
        outerCircle.path = UIBezierPath(ovalInRect: CGRect(x: 0.0, y: 0.0, width: frameSize.width, height: frameSize.height)).CGPath
    outerCircle.lineWidth = 8.0
    outerCircle.strokeStart = 0.0
    outerCircle.strokeEnd = 0.45
    outerCircle.lineCap = kCALineCapRound
    outerCircle.fillColor = UIColor.greenColor().CGColor
    outerCircle.strokeColor = UIColor.greenColor().CGColor
    outerCircleView.layer.addSublayer(outerCircle)

    outerCircle.strokeStart = 0.0
    outerCircle.strokeEnd = 1.0

    vibrancyView.contentView.addSubview(outerCircleView)

    innerCircleView.frame.size = frameSize

    let innerCirclePadding: CGFloat = 12
    innerCircle.path = UIBezierPath(ovalInRect: CGRect(x: innerCirclePadding, y: innerCirclePadding, width: frameSize.width - 2*innerCirclePadding, height: frameSize.height - 2*innerCirclePadding)).CGPath
    innerCircle.lineWidth = 4.0
    innerCircle.strokeStart = 0.5
    innerCircle.strokeEnd = 0.9
    innerCircle.lineCap = kCALineCapRound
    innerCircle.fillColor = UIColor.greenColor().CGColor
    innerCircle.strokeColor = UIColor.greenColor().CGColor
    innerCircleView.layer.addSublayer(innerCircle)

I'd like to have the circles change colors.

A: A path has no color. It's a path! Only a graphics context has a stroke color / fill color. Sooner or later you will have a graphics context - a bezier path is useless without one. When you do, set its path to your bezier path, set its stroke / fill color as desired, and then stroke / fill the path. Voilà.
In your case, you seem to have a pair of CAShapeLayer objects. You can change their stroke / fill colors, because they have a graphics context - they take the path and colors you give them, and draw them for you by filling and stroking the path. Fine. But you cannot change a bezier path's stroke or fill color - it's just a path. The entire notion is meaningless.
Having said all that, it is far from clear what issue you are having. Based on your code, I ran this bit of it:
class ViewController: UIViewController {
    @IBOutlet weak var outerCircleView: UIView!

    override func viewDidLoad() {
        super.viewDidLoad()
        let outerCircle = CAShapeLayer()
        let frameSize = outerCircleView.frame.size
        outerCircle.path = UIBezierPath(ovalInRect: CGRect(x: 0.0, y: 0.0, width: frameSize.width, height: frameSize.height)).CGPath
        outerCircle.lineWidth = 8.0
        outerCircle.strokeStart = 0.0
        outerCircle.strokeEnd = 0.45
        outerCircle.lineCap = kCALineCapRound
        outerCircle.fillColor = UIColor.clearColor().CGColor
        outerCircle.strokeColor = UIColor.grayColor().CGColor
        outerCircleView.layer.addSublayer(outerCircle)

    }
}

It builds and runs, and I see exactly what I would expect to see: a thick gray part-circle:

That is because this shape layer has a clear fill color and a grey stroke color. If you don't like those colors, ask the shape layer to give you different colors.
UPDATE You updated your code to show a second version involving green fill and stroke. So I tried your second code:
override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view, typically from a nib.

    let outerCircle = CAShapeLayer()
    let frameSize = outerCircleView.frame.size
    outerCircle.path = UIBezierPath(ovalInRect: CGRect(x: 0.0, y: 0.0, width: frameSize.width, height: frameSize.height)).CGPath
    outerCircle.lineWidth = 8.0
    outerCircle.strokeStart = 0.0
    outerCircle.strokeEnd = 0.45
    outerCircle.lineCap = kCALineCapRound
    outerCircle.fillColor = UIColor.greenColor().CGColor
    outerCircle.strokeColor = UIColor.greenColor().CGColor
    outerCircleView.layer.addSublayer(outerCircle)

    outerCircle.strokeStart = 0.0
    outerCircle.strokeEnd = 1.0

}

And, as expected, I got a green circle (it isn't an exact circle, but that is just because my view is not a perfect square):

So again I don't see what the problem is supposed to be: your code does just what I would expect your code to do.

redpajama_set_name: RedPajamaStackExchange


text:
LETTER TO EDITOR FROM JIM & JESSICA
MORE ABOUT JIM - INQUIRER 5/14
MORE ABOUT JESSICA - INQUIRER 5/3
MORE ABOUT JIM - 10583.com
MORE ABOUT JESSICA - 10583.com
REPLAY 5/2 LWV VIDEO
MEET & GREET / Q&A SESSIONS
JIM and JESS and YES
SUPPORT LETTERS
INQUIRER AD 5/7/21
Introducing Journalist, Author, Community Volunteer and Candidate for Scarsdale School Board Jessica Resnick-Ault
Written By Joanne Wallenstein
Appeared in Scarsdale 10583 on April 22nd, 2021
Please introduce yourself to our readers.
Hi! I'm Jessica Resnick-Ault, I'm the mom of a fifth grader at Edgewood, and have lived in Scarsdale since 2014, and in Westchester since 2012. I'm a journalist, editor and published author. I currently work for Reuters, covering energy policy and markets. For the past 20 years, I have covered broad ranging topics for Reuters, Bloomberg and Dow Jones/Wall Street Journal and Providence Journal. I have covered everything from No Child Left Behind to municipal bonds to the Enron trial and Deepwater Horizon disaster. In 2015, I wrote a book on Hess - the oil company best known for its toy trucks. I have done a wide variety of community service, particularly in education, over the past two decades, and come from a family of educators. My husband, Peter Gimbel, died in 2017 of complications from Duchenne Muscular Dystrophy, and continues to be one of my biggest inspirations for his calm and perseverance in the face of adversity.
Why did you decide to run this year?
When I was approached and asked to submit an application to the board, I decided to go through the SBNC vetting process because I care deeply about the future of Scarsdale schools. Not just this school year and next, not only the recovery from COVID, but the health and growth of the schools over the next decade, and the ones after that. I believe that the excellence of our schools sets us apart from many communities, not just regionally, but nationally, and is a key part of what makes our village an attractive and welcoming one to live in. I am compelled to serve at a time when reopening in the wake of the pandemic is a critical mission, but it is not my sole focus. I believe that it is crucial to have a board that can simultaneously manage short term objectives and still consider big-picture vision and mission so that we have a system that is resilient and continues to evolve. Scarsdale deserves a district that stays at the forefront pedagogically and technologically and is prepared for ever-changing new challenges. Scarsdale also deserves a board that makes all stakeholders feel appreciated and listened to and is respectful of prismatic views.
How do you expect your skills as a journalist to inform your work on the Board of Education?
I am at my best as a journalist when I am on the phone or in person, talking to people to learn every side of an issue. Researching and reading enable me to stay informed, so that I can formulate questions that I know my readers want answered. For the board of education, that would translate into being able to have the pulse of what is important to the community and keep that in mind as I research upcoming policies, look at how they have been implemented elsewhere, and bring up questions that are pressing to the community before making a decision. As a journalist, I have carefully covered the post-mortem on events like Hurricane Sandy, Hurricane Katrina, Deepwater Horizon and others that disrupted municipal life. I am ready to look at the strengths and weaknesses that our district showed in the past year and help formulate a mission going forward so that we are stronger for the future.
You did considerable charitable work during the pandemic. Explain what you did and who you helped.
I have always been committed to community service, but when the pandemic hit, like many residents, I felt isolated and powerless in the face of uncertainty. Small efforts to help first responders ballooned as I joined with Bake Back America founder Melissa Subin to meet the needs of people across Westchester and New York. I realized there were opportunities to use Bake Back America's connections with non-profits to identify critical needs and source those items from families in Scarsdale, who were at a loss with where to donate as many local non-profits closed.
I started Bake Back America's Grant a Wishlist program, which delivered over 8,000 bags of needed clothes, blankets, and supplies to families in need across Westchester and the Bronx, teaming up with 45 different partner non-profit organizations. We have constantly grown and taken on new initiatives and a more educational bent. The organization offers over 250 hours a week of free tutoring to children in need, sponsors extra-curricular efforts for low-income families and has provided learning devices to children who would have been unable to attend virtual school otherwise. The efforts are now national with programs ranging from Massachusetts to Alaska, and we have even looped in international volunteers who help to fill certain language gaps. While the goal is to help our recipients, I have especially enjoyed working with our volunteers, who have tirelessly come together as families and communities to support those in need in a safe and socially-distanced way during what can otherwise be an isolating time. From first-graders to at least one 84-year-old, we have had volunteers from every age, race, and socioeconomic demographic, and I have been delighted to work with all of them and get to know everyone better.
I have also been the community service chair for the Edgewood PTA during this time. In this role, I have worked with an excellent committee and leadership to think about ways to engage students in service and new opportunities during a time when traditional efforts, like the holiday gift drive, were harder to execute due to changed traffic flow at schools. Despite these hurdles, we have engaged in new partnerships this year, and continued to grow the community service program.
Tell us about your experience as a union manager. What insights did that give you (if any) into the relationship between the teachers' union and the administration, especially this past year?
As a journalist, I have been both a union member, and a union manager. One of the greatest successes I have seen has come through the partnership committee in which a dozen managers and members meet routinely to discuss issues outside of contract bargaining. These sessions have been extremely valuable for hearing perspectives on crucial topics like diversity, equity, and inclusion, return protocols after COVID 19, corporate culture and employee retention. By separating these conversations from collective bargaining, creative solutions can emerge. I believe that having these types of meetings routinely can promote unity that persists even during difficult periods when contract negotiations are underway. Animosity between two entities like the union and school board or parents is counterproductive in recruiting the top pool of diverse teachers to Scarsdale, and so it is critical that we bring the community together in the coming years.
Do you think that the community's expectations of the role of the Board of Education changed this year? If so, how?
Yes - this was evident from meetings early in the year, when parents who had never attended board meetings before became active, coming to the forefront with concerns and wanting a more robust platform for communicating with the board. I think parents who have counted on schools as a cornerstone of our community's strength were shaken to the core when schools shut, perhaps more than in some other districts, where schools have been less trusted entities. As a result, questions on process, transparency and technology all received scrutiny at a higher level than in the past. The community wanted more space to be heard, and the board has recently taken some good initial steps to set up coffees and other forums for more interaction going forward.
Looking back at the past year, it appeared that some parents were unhappy with the district's decision making process, transparency and communications? How could these be improved down the line?
In a year with many unknowns, it was important for parents and community members to feel well informed about rapidly changing information, and to understand what was being taken into consideration as plans were made that profoundly impacted district children, families and educators. More open listening sessions at a variety of times to truly understand stakeholder positions could have been helpful, in hindsight. It is critical that we look at districts where the roll out of remote learning, hybrid programs, and ultimately in-person learning went more smoothly, because stakeholders felt included and had more room to voice their opinions. We can look to the districts as models for how stakeholders were made to feel they had a voice. The current board has already begun to take some steps to evaluate better forums for community participation in the future, such as holding informal coffees. Still, more opportunities are needed, particularly in times of crisis. I am open to hearing what would be most valuable to the community and incorporating more options.
In your view, what are some of the challenges the district could face next school year?
After the unexpected twists and turns of the past 13 months, I don't want to hazard any predictions. That said: the district must conduct a thorough review of how the events of the past year were handled, so that a robust and flexible plan for future crises is in place, so that we can replicate some of our strongest wins and reduce some of the most problematic concerns we faced. While the next challenge we face could be entirely different, it is critical that we are ready to face whatever lies ahead as a unified district, respectful of varying viewpoints.
This year, the SBNC did not re-nominate the current Vice President and two candidates are running independently. What do you think this indicates about community opinion and the School Board Nominating Committee process?
I think the SBNC had a number of candidates to consider, though obviously those exact proceedings are confidential. Speaking only for my own experience, I believe that the SBNC did a thorough job in checking my references and reviewing my record. I believe the SBNC picked two nominees with a record of service to the community, who have served as consensus builders on different boards, but are unafraid to ask questions or gather input from many stakeholders in the interest of providing every Scarsdale child with a top education.
What do you enjoy about living in Scarsdale? When you get a free minute, what do you do for fun?
First and foremost, I enjoy spending time with my daughter, friends and neighbors- within just a few blocks we have people from across the country and around the world and have made important and lasting friendships with them -- while my yard is small, I have been grateful to have had enough outdoor space to gather with a few others during the pandemic, to share s'mores and fire-pit time to fight off isolation. Over the years, as some neighbors have moved away to other cities or countries, I have been lucky to stay in touch with many, giving us a network of people who we plan to see in future post-pandemic travels. For fun, I also love biking in this area! I rarely rode a bike as a kid growing up in a densely populated exurb of Boston and have embraced biking since living in Scarsdale - my daughter and I often attend Bicycle Sundays and were glad they were more frequent during the pandemic. When it's not Sunday, we like the readily available county trail network, and even did 40 miles for my 40th birthday this past summer! I enjoy reading (most recent book: The Topeka School) and can't wait to see the new library space. Bronx River Bookstore is probably my favorite shop in our village - it's a great addition and I'm glad to stop in often.
Anything else you wish to add?
One thing that often doesn't get much attention is my general interest in education. My grandmother Helen, my biggest personal influence and my daughter's namesake, was a public school teacher in Brooklyn from the 1920s until the 1970s, and my parents, brother, aunt, uncle, cousins and sister-in-law are all educators at different levels. While my professional path took a different turn, I have always volunteered in education, working with significant barriers to learning (socioeconomic and biological) as well as students with more advantaged learning profiles.
I first became interested in educational policy while studying Public Policy at Brown University. As a result, I interned at the Harvard Graduate School of Education, contributing to Dr. Jean Rhodes' work on the risks and rewards of mentoring youth.
After college, I spent my remaining two years in Rhode Island working as a reporter, covering school boards in an affluent community and a low-income one, and covering the roll out of No Child Left Behind in Massachusetts. During that time, I volunteered at the Rhode Island Training School for Youth, a locked detention facility, working specifically on issues pertaining to education of female inmates, who, at that time, had fewer learning opportunities than male inmates.
In 2004, I moved to Houston, Texas, where I did outreach and interviewing for Brown University, traveling on weekends to help students in rural areas surrounding Houston expand their knowledge of a broad range of out-of-state schools. During that time, I also became active in the Muscular Dystrophy Association, co-facilitating a Spanish language group for families with members with muscular dystrophy and co-facilitating a young-adult group for people with muscular dystrophy and their caregivers. This work inherently touched on access to education, as many of the families we worked with lacked knowledge of then-current policies around in-school accommodations.
In Scarsdale, I have served as a class parent at the Pre-K and elementary level, taken on volunteer roles such as offering classes in the young writer's workshop and volunteered with the PTA in myriad capacities, most recently as co-chair of the community service committee at Edgewood.
Email: coalitionforscarsdaleschools@gmail.com
© Copyright 2021 by Coalition for Scarsdale Schools
Website design: ML Perlman; Graphics: Diane Greenwald; 2021 Webmaster: David Fenigstein

redpajama_set_name: RedPajamaCommonCrawl


text:
Tau in line to make Premier League debut
Jan 12, 2021 - 05:31 pm By Liam Bekker
Brighton & Hove Albion boss Graham Potter has hinted that Percy Tau could be in contention to make his Premier League debut against Manchester City on Wednesday.
Nearly two-and-a-half years after first signing for the club from Mamelodi Sundowns, Tau made his debut for Brighton on Sunday evening when he featured a second-half substitute during a 1-1 (4-3) penalty shootout win over Newport County in the FA Cup.
Scroll through the gallery above to see images of Percy Tau at Brighton & Hove Albion
"We're excited of course, he's only been with us a few days, but I think you can see his quality," club manager Potter reflected on the 26-year-old's performance during in his pre-match press conference ahead of the Seagulls' clash against City.
"It's a difficult environment for him to make his debut in, away at Rodney Parade, it's a unique football environment there, but he just got on with it. You can see his ability and what he brings. We're looking forward to getting to know him better and him getting to know us better and I think that's how the relationship improves."
READ: Tau: What Kompany said before PL move
Following his impressive cameo on debut, Tau now looks set to make his maiden appearance in the Premier League where a potential baptism of fire awaits him on Wednesday evening in the form of Pep Guardiola's formidable title-contenders.
Whether the 26-year-old is handed a starting role remains to be seen, but with Alireza Jahanbakhsh doubtful and forwards Danny Welbeck, Aaron Connolly, Jose Izquierdo and Florin Andone all out injured, he may well be thrown into the thick of things at the Etihad Stadium.
"We're having a little bit of a tough moment where we are [in terms of injuries] so it's nice to have a fresh face, someone to come in and add that enthusiasm," Potter added. "I think the players have taken to him, they can see what he brings and, like I said, I think we'll get better the longer we work with each other."
Brighton & Tau learn FA Cup fate
Tau: What Kompany said before PL move
Tau reacts to fanatical SA support


Tuina massage provides a healthcare routine that makes your touch an important part of daily life, strengthening your relationship and nurturing your child in body, mind and spirit. This unique form of health-care was developed in China to promote the development of a healthy body, a strong immune system, and also to stimulate the brain during the child's most crucial formative period – up to the age of 6 years.
In China, Tuina is still used in hospitals today for the treatment of illness as well as for ensuring healthy child development.
It is an extremely safe form of treatment, treating the child as a whole person, without unwanted side-effects and with the advantages that a child does not have to undress and can even be gently massaged while asleep. Baby Tuina is proving valuable as a natural response to common health problems.


Jodie, LLC is a food business that strives for outstanding excellence. We pride ourselves on integrity, honesty and using the freshest products.
Complement and exceed the expectations of our customers.
Make and leave a remarkable foot (food) print on how we delivery our food service.
Leave a remarkable, unforgettable food experience in its purest form.


Victor Roelens was the first Catholic missionary bishop of the Democratic Republic of the Congo. By nature, he was authoritarian and pragmatic, hard and obstinate. A Belgian, he was born at Ardooie in the Diocese of Bruges, western Flanders. His father was a gardener employed by the Count de Jonghe and Roelens inherited his respect for, and love of, manual work. From 1873 to 1879 he attended Tielt College and then studied philosophy for a year at the seminary of Roulers. In September 1880 he entered the novitiate of the Missionaries of Africa at Algiers, and after theological studies at Carthage in Tunisia, was ordained priest by the founder, Cardinal Lavigerie.
For seven years Roelens was employed in Europe and the Near East. He worked mainly in Belgium, setting up the anti-slavery committee there, and then taught at the Greek Melchite seminary of St. Anne's Jerusalem. Roelens shared this Jerusalem experience with several other bishops of Equatorial Africa who, like him, started seminaries for training African priests. In 1891, Roelens was appointed to Upper Congo, and travelled to Lake Tanganyika with the tenth caravan of the Missionaries of Africa, reaching the lake in the following year. Upper Congo became a separate jurisdiction in 1893 with Roelens as administrator. When it became a Vicariate Apostolic in 1895, Roelens was appointed its bishop, the first of the colony. He returned to Belgium and was ordained bishop at Malines by Cardinal Goossens.
Various consequences followed from this state of affairs. One was that the missions continued for some years to be reception stations for orphans, ransomed slaves, and other casualties of violence. In fact, education in Upper Congo revolved around institutional orphanages and Christian settlements long after such things had disappeared in other parts of Africa. Another consequence was that the Catholic Church was in such a strong position when the colonial administration was effectively established that it virtually shared civil power with the state. The 1906 concordat with the Vatican allocated substantial areas of land to the church, as well as subsidies for Catholic schools. The atrocities associated with the exploitation of wild rubber in the Congo did not occur in the Upper Congo vicariate, but when they began to be made known, Roelens believed them a calumny against the Belgian king. Roelens was decorated many times by the Belgian government, and he must have come near to Leopold II's ideal of a Belgian Catholic missionary. However, he did not see eye to eye completely with the government, especially on the subject of military youth camps and trade schools, and he feared the influence of freemasonry in government circles. In 1908, he took the important step of convening, and presiding over, a meeting of Catholic religious superiors at Leopoldville (Kinshasa).
In 1893 Roelens started a catechist training centre at Mpala, and this moved to the new mission station of Lusaka in 1905. Under government impulse, it eventually became a teacher training centre. The schools and orphanages of Upper Congo remained firmly in the hands of the church which attempted to shield the pupils from secular influences. Roelens drew up a catechism in Swahili and enunciated his missionary policies through rigid circulars and instructions to his missionaries. A junior seminary stream developed alongside the catechist centre at Lusaka. In this, the students were allowed to learn French, as well as Latin, and classical authors, such as Cicero, were studied. In 1907 a major seminary was started at Baudouinville, and this produced the first Congolese priest, Stephen Kaoze, who was ordained by Roelens in 1917. The success of the seminary and the perseverance of Kaoze probably owed more to the support of Roelens' auxiliary bishop, Auguste Huys, than to Roelens himself.
Huys died in 1931 and Roelens received Morlion as coadjutor in 1939. When Roelens resigned in 1941, after forty-six years as bishop, his vicariate had 52,000 baptized Christians, eighty-four outstation chapels and 391 village schools. He spent his last six years of retirement in study and prayer. Dying at the age of 89, he had outlived more than sixty of his missionaries. Although he was a controversial and in many ways an unattractive character, Roelens was a major founder of the Catholic Church in the Democratic Republic of the Congo.
Roger Heremans, L'Education dans les Missions des Pères Blancs en Afrique Centrale 1879-1914 (Brussels: Editions Nauwelaerts, 1983).
Victor Roelens, (ed. Antoine, N.) Notre Vieux Congo 1891-1917, Souvenirs du Premier Evêque du Congo Belge, 2 vols, (Namur: Editions Grands Lacs, 1948).
Friedrich Stenger, White Fathers in Colonial Central Africa - A Critical Examination of V. Y. Mudimbe's Theories on Missionary Discourse in Africa (Münster, Hamburg, London: Lit Verlag, 2001).


JADUGUDA URANIUM DEPOSIT, SINGHBHUM, INDIA 1 a Map of India . 1985 : Geology and ore mineralisation of the Singhbhum copperuranium belt,.
Sep 15, 2016 Indiaplete the second phase of its mining auctions later this month, blocks of limestone and one block each of gold, diamond and copper. of ore and low quality of the mineralization studies, among other reasons.
Australia is a major copper Cu producer with mining and smelting operations was in the search for further Olympic Dam style mineralisation in the Gawler Craton. .. to parent Hindalco Coppers Dahej smelting and refining facility in India.
Nov 14, 2013 What A Porphyry Copper Ore Body Tells Us About How India Was Assembled The Malanjkhand ore mineralization which is dated to about 2.
Aligarh, India The Khetri Copper Belt, which extends for about 80 km from Singhana Mineralization of copper has largely been at or near the contact of.
Geological Survey of India first reported uranium mineralisation at. Turamdih mineralisation is also associated with copper mineralisation, prominent lodes of.
Copper mineralisation occurring in . Copper mineralisation is present as stockwork veining and trade links with India through the signing of a Partial.
RAO, S. K. L., 1971 Note on copper mineralisation in Agnigundala, Andhra Pradesh. Geol. Surv. India, Miscellaneous Publication, v. 16, Base Metals, Part I, pp.
M.K. Panigrahi · A. Mookherjee. The Malanjkhand copper + molybdenum deposit, India: mineralization from a lowtemperature orefluid of granitoid affiliation.
Jagreet Ki. G4 was carried out to assess the. Dhani potentiality of copper mineralisation in depth as well as strike extension in alluvialcovered area. Sulphide.
SINGHBHUM COPPER BELT, INDIA with uranium mineralization at Jadugada Fig. 1. In the copper ores, mackinawite has developed exclusively within.
In the AravalliDelhi belt of northwestern India the Archaean Bhilwara Supergroup and leadzinccopper mineralisation is present in the southern part, in.
It is concluded on the importance of studying the copper mineralization in the Deccan Trap. Keywords: Deccan Basalts, India, Copper, quartz tholeiites.
Oct 12, 2007 hum Shear Zone SSZ in eastern India hosts Indias largest. U and Cu deposits .. dozen spatially distinct areas of mineralization of copper.
equivalent to just five year of copper production in India. India share of world metal and copper mineralization out of which is 60,000 sq, km in potential area.
Surda is a Copper Mine in India owned by Hindustan Copper, India from metres up to 60m in thickness as the copper mineralisation pinches and swells.
Abstract: The present study indicate that the copper mineralization in the area is of the nature of scattered Arcot and Tiruchirapalle districts of South India.
Feb 14, 2017 The average grade of gold ore produced in India . identify zones of gold mineralisation. .. the potentiality of goldcopper mineralisation.


At Columbia Athletic Clubs you will find a variety of options to compliment your fitness needs, as well as programs and services for you and your family. We encourage you to not only join us, but to become involved in our programs and enjoy the amenities that set us apart.
Trial pass is for first time users only and includes Athletic amenities only. Guests must be 21 or older with a valid photo ID. Must be a local resident within 20 miles of the club. Kids' Club, Personal Training, Massage, and Outdoor pool are available for an additional fee.
Columbia Athletic Clubs respects your privacy and will not distribute your personal information to any third party. This information is only used to complete our trial pass registration. Registering guest users is done to protect the safety of our members and guests while using our facilities.


Dudley and Carol King of 4102 McKeith St. are celebrating their 50th wedding anniversary. The former Carol Adrian married King Nov. 12, 1955 in Saginaw. They have two children: Amy Kutschinski of Midland and Kathy Wollensak of Holt. They also have four grandchildren. Dudley retired from The Dow Chemical Co. Carol is a homemaker. A family dinner is planned.


Here is another late entry into the weekly challenge brought to us by the lovely Rochelle Wisoff-Fields.
The mountains of paperwork had reached mammoth proportions.
Deluged by policies, amendments, white papers and term sheets, her desk had disappeared long ago.
There was a knock at her office door.
The air hung heavy with expectation, desperation even.
The timid girl entered, hovering near the door.
"S-sorry," she said, her voice barely above a whisper. She darted forward, placed a Perspex sign on top of one of the paper towers and left – quickly.
Clare picked up the sign and rolled her eyes.
"'Head of Environmental Policy' indeed," she muttered.
Maybe climate change will blow away all the papers. Very funny story!
Excellent! Which reminds me…I'd better stop asking for paper receipts…and go with emails instead. At 65, it's difficult to undo longstanding habits…especially when I'm hung up on security breaches. I should let go though…for the environment's sake.
Oh yes, old habits die hard… and I was a little suspicious the first time Apple offered to email me my receipt from their handheld gizmo… all this new technology!
It certainly is hard to change (I'm also paper led…).
Nice message and an original take on the prompt.
That's a no-win for all concerned. Best pack it in and go hiking.
I'm sure she's an avid recycler, darling. Plus, she goes on Facebook and "Likes" all those posts about saving the planet, so it all evens out.
lol ironic indeed! 🙂 funny.
Great little story. I love a bit of irony!
Very funny, Freya! And bureaucracy is just as twisted as these trees, too.
Perhaps she can shred the sign and use it for mulch. 😉 Love your unique take on the prompt.
Freya, exquisite irony here and an excellent story.
Well written Freya, definitely very ironic.
Love the voice in this, the irony and desperation both so well done.
Irony…I love it! Nicely done.


text:
Q: ActionMailer rails, how to send diffrent content to cc: @email? I send an email after the user creates a record, I'm sending some data of the record to: @email and I need to send to cc: cc@email all the record information. How can I do that?
  def appointment_confirmation(appointment)
    @appointment = appointment
    @greeting = "Hi"

    mail to: appointment.email, subject: "Appointment Confirmation", cc: "cc@email"
  end

A: You can't. You need to send a separate email using a separate template.
CC means "Carbon Copy" and can only be the exact same email.