//
// Copyright 2020 FoxyUtils ehf. All rights reserved.
//
// This is a commercial product and requires a license to operate.
// A trial license can be obtained at https://unidoc.io
//
// DO NOT EDIT: generated by unitwist Go source code obfuscator.
//
// Use of this source code is governed by the UniDoc End User License Agreement
// terms that can be accessed at https://unidoc.io/eula/

// Package ps implements various functionalities needed for handling Postscript for PDF uses, in particular
// for PDF function type 4.
//
// Package ps implements various functionalities needed for handling Postscript for PDF uses, in particular
// for PDF function type 4.
package ps

import (
	_gb "bufio"
	_g "bytes"
	_b "errors"
	_ad "fmt"
	_c "gitee.com/zhaobingss/unipdf/v3/common"
	_d "gitee.com/zhaobingss/unipdf/v3/core"
	_a "io"
	_ba "math"
)

func (_cbag *PSOperand) ln(_fbbf *PSStack) error {
	_geec, _gcce := _fbbf.PopNumberAsFloat64()
	if _gcce != nil {
		return _gcce
	}
	_gcg := _ba.Log(_geec)
	_gcce = _fbbf.Push(MakeReal(_gcg))
	return _gcce
}
func (_f *PSBoolean) DebugString() string {
	return _ad.Sprintf("\u0062o\u006f\u006c\u003a\u0025\u0076", _f.Val)
}

const _gc = 0.000001

func (_bead *PSOperand) neg(_dbeeg *PSStack) error {
	_ceec, _cbcd := _dbeeg.Pop()
	if _cbcd != nil {
		return _cbcd
	}
	if _eaf, _aeb := _ceec.(*PSReal); _aeb {
		_cbcd = _dbeeg.Push(MakeReal(-_eaf.Val))
		return _cbcd
	} else if _agd, _eag := _ceec.(*PSInteger); _eag {
		_cbcd = _dbeeg.Push(MakeInteger(-_agd.Val))
		return _cbcd
	} else {
		return ErrTypeCheck
	}
}

// Execute executes the program for an input parameters `objects` and returns a slice of output objects.
func (_ae *PSExecutor) Execute(objects []PSObject) ([]PSObject, error) {
	for _, _dce := range objects {
		_aec := _ae.Stack.Push(_dce)
		if _aec != nil {
			return nil, _aec
		}
	}
	_af := _ae._eb.Exec(_ae.Stack)
	if _af != nil {
		_c.Log.Debug("\u0045x\u0065c\u0020\u0066\u0061\u0069\u006c\u0065\u0064\u003a\u0020\u0025\u0076", _af)
		return nil, _af
	}
	_ed := []PSObject(*_ae.Stack)
	_ae.Stack.Empty()
	return _ed, nil
}

var ErrStackUnderflow = _b.New("\u0073t\u0061c\u006b\u0020\u0075\u006e\u0064\u0065\u0072\u0066\u006c\u006f\u0077")

func (_gaac *PSOperand) eq(_eddc *PSStack) error {
	_cfe, _gcf := _eddc.Pop()
	if _gcf != nil {
		return _gcf
	}
	_ffb, _gcf := _eddc.Pop()
	if _gcf != nil {
		return _gcf
	}
	_bdd, _bdf := _cfe.(*PSBoolean)
	_gde, _efff := _ffb.(*PSBoolean)
	if _bdf || _efff {
		var _bcf error
		if _bdf && _efff {
			_bcf = _eddc.Push(MakeBool(_bdd.Val == _gde.Val))
		} else {
			_bcf = _eddc.Push(MakeBool(false))
		}
		return _bcf
	}
	var _cee float64
	var _ccec float64
	if _edb, _geb := _cfe.(*PSInteger); _geb {
		_cee = float64(_edb.Val)
	} else if _ade, _gdb := _cfe.(*PSReal); _gdb {
		_cee = _ade.Val
	} else {
		return ErrTypeCheck
	}
	if _ega, _dfb := _ffb.(*PSInteger); _dfb {
		_ccec = float64(_ega.Val)
	} else if _faee, _eca := _ffb.(*PSReal); _eca {
		_ccec = _faee.Val
	} else {
		return ErrTypeCheck
	}
	if _ba.Abs(_ccec-_cee) < _gc {
		_gcf = _eddc.Push(MakeBool(true))
	} else {
		_gcf = _eddc.Push(MakeBool(false))
	}
	return _gcf
}

// PopNumberAsFloat64 pops and return the numeric value of the top of the stack as a float64.
// Real or integer only.
func (_faff *PSStack) PopNumberAsFloat64() (float64, error) {
	_fcca, _cbef := _faff.Pop()
	if _cbef != nil {
		return 0, _cbef
	}
	if _ebgb, _befe := _fcca.(*PSReal); _befe {
		return _ebgb.Val, nil
	} else if _gdfb, _egab := _fcca.(*PSInteger); _egab {
		return float64(_gdfb.Val), nil
	} else {
		return 0, ErrTypeCheck
	}
}
func (_cba *PSReal) DebugString() string {
	return _ad.Sprintf("\u0072e\u0061\u006c\u003a\u0025\u002e\u0035f", _cba.Val)
}
func (_cb *PSInteger) String() string { return _ad.Sprintf("\u0025\u0064", _cb.Val) }
func (_dgad *PSOperand) truncate(_cfdg *PSStack) error {
	_cega, _gab := _cfdg.Pop()
	if _gab != nil {
		return _gab
	}
	if _aeg, _gad := _cega.(*PSReal); _gad {
		_cgbc := int(_aeg.Val)
		_gab = _cfdg.Push(MakeReal(float64(_cgbc)))
	} else if _baac, _cdc := _cega.(*PSInteger); _cdc {
		_gab = _cfdg.Push(MakeInteger(_baac.Val))
	} else {
		return ErrTypeCheck
	}
	return _gab
}

// Exec executes the program, typically leaving output values on the stack.
func (_ada *PSProgram) Exec(stack *PSStack) error {
	for _, _eff := range *_ada {
		var _dfe error
		switch _bb := _eff.(type) {
		case *PSInteger:
			_ff := _bb
			_dfe = stack.Push(_ff)
		case *PSReal:
			_gac := _bb
			_dfe = stack.Push(_gac)
		case *PSBoolean:
			_ebc := _bb
			_dfe = stack.Push(_ebc)
		case *PSProgram:
			_fa := _bb
			_dfe = stack.Push(_fa)
		case *PSOperand:
			_ab := _bb
			_dfe = _ab.Exec(stack)
		default:
			return ErrTypeCheck
		}
		if _dfe != nil {
			return _dfe
		}
	}
	return nil
}
func (_gaacb *PSOperand) lt(_dgc *PSStack) error {
	_cabg, _bcc := _dgc.PopNumberAsFloat64()
	if _bcc != nil {
		return _bcc
	}
	_faga, _bcc := _dgc.PopNumberAsFloat64()
	if _bcc != nil {
		return _bcc
	}
	if _ba.Abs(_faga-_cabg) < _gc {
		_cca := _dgc.Push(MakeBool(false))
		return _cca
	} else if _faga < _cabg {
		_agf := _dgc.Push(MakeBool(true))
		return _agf
	} else {
		_ceg := _dgc.Push(MakeBool(false))
		return _ceg
	}
}
func (_ddd *PSInteger) DebugString() string {
	return _ad.Sprintf("\u0069\u006e\u0074\u003a\u0025\u0064", _ddd.Val)
}
func (_fgg *PSParser) parseOperand() (*PSOperand, error) {
	var _eegc []byte
	for {
		_bfbc, _fec := _fgg._dddb.Peek(1)
		if _fec != nil {
			if _fec == _a.EOF {
				break
			}
			return nil, _fec
		}
		if _d.IsDelimiter(_bfbc[0]) {
			break
		}
		if _d.IsWhiteSpace(_bfbc[0]) {
			break
		}
		_aag, _ := _fgg._dddb.ReadByte()
		_eegc = append(_eegc, _aag)
	}
	if len(_eegc) == 0 {
		return nil, _b.New("\u0069\u006e\u0076al\u0069\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064\u0020\u0028\u0065\u006d\u0070\u0074\u0079\u0029")
	}
	return MakeOperand(string(_eegc)), nil
}
func (_bd *PSOperand) String() string { return string(*_bd) }

// Append appends an object to the PSProgram.
func (_aef *PSProgram) Append(obj PSObject) { *_aef = append(*_aef, obj) }
func (_efa *PSProgram) String() string {
	_adg := "\u007b\u0020"
	for _, _edd := range *_efa {
		_adg += _edd.String()
		_adg += "\u0020"
	}
	_adg += "\u007d"
	return _adg
}
func (_ebg *PSOperand) ne(_cac *PSStack) error {
	_bcfc := _ebg.eq(_cac)
	if _bcfc != nil {
		return _bcfc
	}
	_bcfc = _ebg.not(_cac)
	return _bcfc
}
func (_edaa *PSOperand) mod(_gbeb *PSStack) error {
	_adbg, _bgf := _gbeb.Pop()
	if _bgf != nil {
		return _bgf
	}
	_ceb, _bgf := _gbeb.Pop()
	if _bgf != nil {
		return _bgf
	}
	_ecb, _bba := _adbg.(*PSInteger)
	if !_bba {
		return ErrTypeCheck
	}
	if _ecb.Val == 0 {
		return ErrUndefinedResult
	}
	_fgf, _bba := _ceb.(*PSInteger)
	if !_bba {
		return ErrTypeCheck
	}
	_cdg := _fgf.Val % _ecb.Val
	_bgf = _gbeb.Push(MakeInteger(_cdg))
	return _bgf
}
func (_acg *PSOperand) not(_cgd *PSStack) error {
	_cbcf, _cceb := _cgd.Pop()
	if _cceb != nil {
		return _cceb
	}
	if _fee, _feb := _cbcf.(*PSBoolean); _feb {
		_cceb = _cgd.Push(MakeBool(!_fee.Val))
		return _cceb
	} else if _dfgc, _afcf := _cbcf.(*PSInteger); _afcf {
		_cceb = _cgd.Push(MakeInteger(^_dfgc.Val))
		return _cceb
	} else {
		return ErrTypeCheck
	}
}
func (_db *PSOperand) abs(_ddc *PSStack) error {
	_dbg, _eda := _ddc.Pop()
	if _eda != nil {
		return _eda
	}
	if _ffa, _dbgc := _dbg.(*PSReal); _dbgc {
		_fga := _ffa.Val
		if _fga < 0 {
			_eda = _ddc.Push(MakeReal(-_fga))
		} else {
			_eda = _ddc.Push(MakeReal(_fga))
		}
	} else if _be, _ec := _dbg.(*PSInteger); _ec {
		_fc := _be.Val
		if _fc < 0 {
			_eda = _ddc.Push(MakeInteger(-_fc))
		} else {
			_eda = _ddc.Push(MakeInteger(_fc))
		}
	} else {
		return ErrTypeCheck
	}
	return _eda
}
func (_gf *PSProgram) DebugString() string {
	_ea := "\u007b\u0020"
	for _, _dfg := range *_gf {
		_ea += _dfg.DebugString()
		_ea += "\u0020"
	}
	_ea += "\u007d"
	return _ea
}
func (_debf *PSOperand) sin(_eec *PSStack) error {
	_ebe, _dde := _eec.PopNumberAsFloat64()
	if _dde != nil {
		return _dde
	}
	_gccc := _ba.Sin(_ebe * _ba.Pi / 180.0)
	_dde = _eec.Push(MakeReal(_gccc))
	return _dde
}
func (_eaa *PSOperand) cvi(_bbd *PSStack) error {
	_dbc, _deca := _bbd.Pop()
	if _deca != nil {
		return _deca
	}
	if _adgd, _bde := _dbc.(*PSReal); _bde {
		_eea := int(_adgd.Val)
		_deca = _bbd.Push(MakeInteger(_eea))
	} else if _ede, _bcd := _dbc.(*PSInteger); _bcd {
		_dbe := _ede.Val
		_deca = _bbd.Push(MakeInteger(_dbe))
	} else {
		return ErrTypeCheck
	}
	return _deca
}
func (_cec *PSOperand) round(_dcga *PSStack) error {
	_adf, _cbce := _dcga.Pop()
	if _cbce != nil {
		return _cbce
	}
	if _debe, _dad := _adf.(*PSReal); _dad {
		_cbce = _dcga.Push(MakeReal(_ba.Floor(_debe.Val + 0.5)))
	} else if _gbc, _cdd := _adf.(*PSInteger); _cdd {
		_cbce = _dcga.Push(MakeInteger(_gbc.Val))
	} else {
		return ErrTypeCheck
	}
	return _cbce
}
func (_ccd *PSOperand) index(_gagd *PSStack) error {
	_ddcd, _eef := _gagd.Pop()
	if _eef != nil {
		return _eef
	}
	_bea, _gebf := _ddcd.(*PSInteger)
	if !_gebf {
		return ErrTypeCheck
	}
	if _bea.Val < 0 {
		return ErrRangeCheck
	}
	if _bea.Val > len(*_gagd)-1 {
		return ErrStackUnderflow
	}
	_bfc := (*_gagd)[len(*_gagd)-1-_bea.Val]
	_eef = _gagd.Push(_bfc.Duplicate())
	return _eef
}
func (_fg *PSOperand) Duplicate() PSObject { _ge := *_fg; return &_ge }

// Parse parses the postscript and store as a program that can be executed.
func (_dcdg *PSParser) Parse() (*PSProgram, error) {
	_dcdg.skipSpaces()
	_efbd, _dgb := _dcdg._dddb.Peek(2)
	if _dgb != nil {
		return nil, _dgb
	}
	if _efbd[0] != '{' {
		return nil, _b.New("\u0069\u006e\u0076\u0061\u006c\u0069\u0064\u0020\u0050\u0053\u0020\u0050\u0072\u006f\u0067\u0072\u0061\u006d\u0020\u006e\u006f\u0074\u0020\u0073t\u0061\u0072\u0074\u0069\u006eg\u0020\u0077i\u0074\u0068\u0020\u007b")
	}
	_dddf, _dgb := _dcdg.parseFunction()
	if _dgb != nil && _dgb != _a.EOF {
		return nil, _dgb
	}
	return _dddf, _dgb
}

// PSReal represents a real number.
type PSReal struct{ Val float64 }

func (_fcg *PSOperand) and(_cc *PSStack) error {
	_aff, _aca := _cc.Pop()
	if _aca != nil {
		return _aca
	}
	_fae, _aca := _cc.Pop()
	if _aca != nil {
		return _aca
	}
	if _ggg, _acd := _aff.(*PSBoolean); _acd {
		_acc, _fbb := _fae.(*PSBoolean)
		if !_fbb {
			return ErrTypeCheck
		}
		_aca = _cc.Push(MakeBool(_ggg.Val && _acc.Val))
		return _aca
	}
	if _ce, _dcc := _aff.(*PSInteger); _dcc {
		_bcg, _fff := _fae.(*PSInteger)
		if !_fff {
			return ErrTypeCheck
		}
		_aca = _cc.Push(MakeInteger(_ce.Val & _bcg.Val))
		return _aca
	}
	return ErrTypeCheck
}
func (_dg *PSReal) String() string { return _ad.Sprintf("\u0025\u002e\u0035\u0066", _dg.Val) }
func (_dgg *PSOperand) bitshift(_deb *PSStack) error {
	_dcd, _bffd := _deb.PopInteger()
	if _bffd != nil {
		return _bffd
	}
	_aece, _bffd := _deb.PopInteger()
	if _bffd != nil {
		return _bffd
	}
	var _gbf int
	if _dcd >= 0 {
		_gbf = _aece << uint(_dcd)
	} else {
		_gbf = _aece >> uint(-_dcd)
	}
	_bffd = _deb.Push(MakeInteger(_gbf))
	return _bffd
}
func (_cce *PSOperand) cvr(_eeaf *PSStack) error {
	_dgae, _gff := _eeaf.Pop()
	if _gff != nil {
		return _gff
	}
	if _fgd, _edc := _dgae.(*PSReal); _edc {
		_gff = _eeaf.Push(MakeReal(_fgd.Val))
	} else if _deg, _acea := _dgae.(*PSInteger); _acea {
		_gff = _eeaf.Push(MakeReal(float64(_deg.Val)))
	} else {
		return ErrTypeCheck
	}
	return _gff
}

// PSOperand represents a Postscript operand (text string).
type PSOperand string

var ErrUndefinedResult = _b.New("\u0075\u006e\u0064\u0065fi\u006e\u0065\u0064\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u0065\u0072\u0072o\u0072")

// MakeReal returns a new PSReal object initialized with `val`.
func MakeReal(val float64) *PSReal { _ebgaa := PSReal{}; _ebgaa.Val = val; return &_ebgaa }

// PSParser is a basic Postscript parser.
type PSParser struct{ _dddb *_gb.Reader }

// PSBoolean represents a boolean value.
type PSBoolean struct{ Val bool }

func (_ef *PSBoolean) String() string { return _ad.Sprintf("\u0025\u0076", _ef.Val) }

// String returns a string representation of the stack.
func (_dcfc *PSStack) String() string {
	_bda := "\u005b\u0020"
	for _, _ggc := range *_dcfc {
		_bda += _ggc.String()
		_bda += "\u0020"
	}
	_bda += "\u005d"
	return _bda
}
func (_bffb *PSParser) parseBool() (*PSBoolean, error) {
	_dcbd, _cbe := _bffb._dddb.Peek(4)
	if _cbe != nil {
		return MakeBool(false), _cbe
	}
	if (len(_dcbd) >= 4) && (string(_dcbd[:4]) == "\u0074\u0072\u0075\u0065") {
		_bffb._dddb.Discard(4)
		return MakeBool(true), nil
	}
	_dcbd, _cbe = _bffb._dddb.Peek(5)
	if _cbe != nil {
		return MakeBool(false), _cbe
	}
	if (len(_dcbd) >= 5) && (string(_dcbd[:5]) == "\u0066\u0061\u006cs\u0065") {
		_bffb._dddb.Discard(5)
		return MakeBool(false), nil
	}
	return MakeBool(false), _b.New("\u0075n\u0065\u0078\u0070\u0065c\u0074\u0065\u0064\u0020\u0062o\u006fl\u0065a\u006e\u0020\u0073\u0074\u0072\u0069\u006eg")
}

// MakeBool returns a new PSBoolean object initialized with `val`.
func MakeBool(val bool) *PSBoolean { _efdg := PSBoolean{}; _efdg.Val = val; return &_efdg }

// PSExecutor has its own execution stack and is used to executre a PS routine (program).
type PSExecutor struct {
	Stack *PSStack
	_eb   *PSProgram
}

func (_fcc *PSOperand) atan(_aced *PSStack) error {
	_bed, _agaf := _aced.PopNumberAsFloat64()
	if _agaf != nil {
		return _agaf
	}
	_afc, _agaf := _aced.PopNumberAsFloat64()
	if _agaf != nil {
		return _agaf
	}
	if _bed == 0 {
		var _beg error
		if _afc < 0 {
			_beg = _aced.Push(MakeReal(270))
		} else {
			_beg = _aced.Push(MakeReal(90))
		}
		return _beg
	}
	_de := _afc / _bed
	_fe := _ba.Atan(_de) * 180 / _ba.Pi
	_agaf = _aced.Push(MakeReal(_fe))
	return _agaf
}
func (_edf *PSProgram) Duplicate() PSObject {
	_eg := &PSProgram{}
	for _, _gg := range *_edf {
		_eg.Append(_gg.Duplicate())
	}
	return _eg
}
func (_edfc *PSOperand) mul(_cgb *PSStack) error {
	_ffaf, _afe := _cgb.Pop()
	if _afe != nil {
		return _afe
	}
	_acde, _afe := _cgb.Pop()
	if _afe != nil {
		return _afe
	}
	_eab, _cbbg := _ffaf.(*PSReal)
	_bef, _abb := _ffaf.(*PSInteger)
	if !_cbbg && !_abb {
		return ErrTypeCheck
	}
	_ceed, _gfb := _acde.(*PSReal)
	_cdea, _cebg := _acde.(*PSInteger)
	if !_gfb && !_cebg {
		return ErrTypeCheck
	}
	if _abb && _cebg {
		_cbc := _bef.Val * _cdea.Val
		_fcgd := _cgb.Push(MakeInteger(_cbc))
		return _fcgd
	}
	var _cag float64
	if _cbbg {
		_cag = _eab.Val
	} else {
		_cag = float64(_bef.Val)
	}
	if _gfb {
		_cag *= _ceed.Val
	} else {
		_cag *= float64(_cdea.Val)
	}
	_afe = _cgb.Push(MakeReal(_cag))
	return _afe
}
func (_aae *PSOperand) exch(_eddb *PSStack) error {
	_gcd, _bec := _eddb.Pop()
	if _bec != nil {
		return _bec
	}
	_bgde, _bec := _eddb.Pop()
	if _bec != nil {
		return _bec
	}
	_bec = _eddb.Push(_gcd)
	if _bec != nil {
		return _bec
	}
	_bec = _eddb.Push(_bgde)
	return _bec
}

// PSObjectArrayToFloat64Array converts []PSObject into a []float64 array. Each PSObject must represent a number,
// otherwise a ErrTypeCheck error occurs.
func PSObjectArrayToFloat64Array(objects []PSObject) ([]float64, error) {
	var _dc []float64
	for _, _cg := range objects {
		if _ag, _ac := _cg.(*PSInteger); _ac {
			_dc = append(_dc, float64(_ag.Val))
		} else if _bc, _dfc := _cg.(*PSReal); _dfc {
			_dc = append(_dc, _bc.Val)
		} else {
			return nil, ErrTypeCheck
		}
	}
	return _dc, nil
}
func (_agb *PSOperand) idiv(_edcb *PSStack) error {
	_dcg, _gdbg := _edcb.Pop()
	if _gdbg != nil {
		return _gdbg
	}
	_bcfe, _gdbg := _edcb.Pop()
	if _gdbg != nil {
		return _gdbg
	}
	_cfeb, _dag := _dcg.(*PSInteger)
	if !_dag {
		return ErrTypeCheck
	}
	if _cfeb.Val == 0 {
		return ErrUndefinedResult
	}
	_degd, _dag := _bcfe.(*PSInteger)
	if !_dag {
		return ErrTypeCheck
	}
	_dfbb := _degd.Val / _cfeb.Val
	_gdbg = _edcb.Push(MakeInteger(_dfbb))
	return _gdbg
}
func (_dbeb *PSOperand) pop(_abad *PSStack) error {
	_, _ffg := _abad.Pop()
	if _ffg != nil {
		return _ffg
	}
	return nil
}
func _fdg(_aaf int) int {
	if _aaf < 0 {
		return -_aaf
	}
	return _aaf
}
func (_bge *PSParser) skipSpaces() (int, error) {
	_bccb := 0
	for {
		_ffgd, _bce := _bge._dddb.Peek(1)
		if _bce != nil {
			return 0, _bce
		}
		if _d.IsWhiteSpace(_ffgd[0]) {
			_bge._dddb.ReadByte()
			_bccb++
		} else {
			break
		}
	}
	return _bccb, nil
}

// Empty empties the stack.
func (_bdfa *PSStack) Empty()               { *_bdfa = []PSObject{} }
func (_dcf *PSInteger) Duplicate() PSObject { _gcb := PSInteger{}; _gcb.Val = _dcf.Val; return &_gcb }
func (_aga *PSOperand) DebugString() string {
	return _ad.Sprintf("\u006fp\u003a\u0027\u0025\u0073\u0027", *_aga)
}
func (_cff *PSOperand) dup(_fag *PSStack) error {
	_gfd, _afa := _fag.Pop()
	if _afa != nil {
		return _afa
	}
	_afa = _fag.Push(_gfd)
	if _afa != nil {
		return _afa
	}
	_afa = _fag.Push(_gfd.Duplicate())
	return _afa
}

// PSProgram defines a Postscript program which is a series of PS objects (arguments, commands, programs etc).
type PSProgram []PSObject

func (_faef *PSOperand) ifCondition(_egd *PSStack) error {
	_cdec, _dfgd := _egd.Pop()
	if _dfgd != nil {
		return _dfgd
	}
	_fdd, _dfgd := _egd.Pop()
	if _dfgd != nil {
		return _dfgd
	}
	_fgb, _fea := _cdec.(*PSProgram)
	if !_fea {
		return ErrTypeCheck
	}
	_cbb, _fea := _fdd.(*PSBoolean)
	if !_fea {
		return ErrTypeCheck
	}
	if _cbb.Val {
		_gag := _fgb.Exec(_egd)
		return _gag
	}
	return nil
}

// NewPSParser returns a new instance of the PDF Postscript parser from input data.
func NewPSParser(content []byte) *PSParser {
	_dgab := PSParser{}
	_fbce := _g.NewBuffer(content)
	_dgab._dddb = _gb.NewReader(_fbce)
	return &_dgab
}

// PSStack defines a stack of PSObjects. PSObjects can be pushed on or pull from the stack.
type PSStack []PSObject

func (_dcda *PSOperand) or(_fde *PSStack) error {
	_ccf, _dfeb := _fde.Pop()
	if _dfeb != nil {
		return _dfeb
	}
	_geaf, _dfeb := _fde.Pop()
	if _dfeb != nil {
		return _dfeb
	}
	if _fgc, _cbab := _ccf.(*PSBoolean); _cbab {
		_gccb, _gfgf := _geaf.(*PSBoolean)
		if !_gfgf {
			return ErrTypeCheck
		}
		_dfeb = _fde.Push(MakeBool(_fgc.Val || _gccb.Val))
		return _dfeb
	}
	if _gcbf, _cffg := _ccf.(*PSInteger); _cffg {
		_bfec, _fddf := _geaf.(*PSInteger)
		if !_fddf {
			return ErrTypeCheck
		}
		_dfeb = _fde.Push(MakeInteger(_gcbf.Val | _bfec.Val))
		return _dfeb
	}
	return ErrTypeCheck
}

var ErrTypeCheck = _b.New("\u0074\u0079p\u0065\u0020\u0063h\u0065\u0063\u006b\u0020\u0065\u0072\u0072\u006f\u0072")

// PopInteger specificially pops an integer from the top of the stack, returning the value as an int.
func (_bede *PSStack) PopInteger() (int, error) {
	_geag, _ddcb := _bede.Pop()
	if _ddcb != nil {
		return 0, _ddcb
	}
	if _cdac, _gabe := _geag.(*PSInteger); _gabe {
		return _cdac.Val, nil
	}
	return 0, ErrTypeCheck
}

// NewPSProgram returns an empty, initialized PSProgram.
func NewPSProgram() *PSProgram { return &PSProgram{} }
func (_gbfa *PSOperand) xor(_edbc *PSStack) error {
	_bcb, _aab := _edbc.Pop()
	if _aab != nil {
		return _aab
	}
	_feg, _aab := _edbc.Pop()
	if _aab != nil {
		return _aab
	}
	if _efe, _accd := _bcb.(*PSBoolean); _accd {
		_dceg, _beadd := _feg.(*PSBoolean)
		if !_beadd {
			return ErrTypeCheck
		}
		_aab = _edbc.Push(MakeBool(_efe.Val != _dceg.Val))
		return _aab
	}
	if _cbg, _bcfa := _bcb.(*PSInteger); _bcfa {
		_bcce, _bdg := _feg.(*PSInteger)
		if !_bdg {
			return ErrTypeCheck
		}
		_aab = _edbc.Push(MakeInteger(_cbg.Val ^ _bcce.Val))
		return _aab
	}
	return ErrTypeCheck
}
func (_cegf *PSParser) parseNumber() (PSObject, error) {
	_aegd, _abc := _d.ParseNumber(_cegf._dddb)
	if _abc != nil {
		return nil, _abc
	}
	switch _bbdf := _aegd.(type) {
	case *_d.PdfObjectFloat:
		return MakeReal(float64(*_bbdf)), nil
	case *_d.PdfObjectInteger:
		return MakeInteger(int(*_bbdf)), nil
	}
	return nil, _ad.Errorf("\u0075n\u0068\u0061\u006e\u0064\u006c\u0065\u0064\u0020\u006e\u0075\u006db\u0065\u0072\u0020\u0074\u0079\u0070\u0065\u0020\u0025\u0054", _aegd)
}

// NewPSStack returns an initialized PSStack.
func NewPSStack() *PSStack { return &PSStack{} }
func (_efda *PSOperand) gt(_acae *PSStack) error {
	_gbe, _gcfg := _acae.PopNumberAsFloat64()
	if _gcfg != nil {
		return _gcfg
	}
	_faeea, _gcfg := _acae.PopNumberAsFloat64()
	if _gcfg != nil {
		return _gcfg
	}
	if _ba.Abs(_faeea-_gbe) < _gc {
		_aac := _acae.Push(MakeBool(false))
		return _aac
	} else if _faeea > _gbe {
		_faf := _acae.Push(MakeBool(true))
		return _faf
	} else {
		_dcfe := _acae.Push(MakeBool(false))
		return _dcfe
	}
}

var ErrStackOverflow = _b.New("\u0073\u0074\u0061\u0063\u006b\u0020\u006f\u0076\u0065r\u0066\u006c\u006f\u0077")

// NewPSExecutor returns an initialized PSExecutor for an input `program`.
func NewPSExecutor(program *PSProgram) *PSExecutor {
	_df := &PSExecutor{}
	_df.Stack = NewPSStack()
	_df._eb = program
	return _df
}
func (_ggf *PSOperand) le(_aad *PSStack) error {
	_ddce, _gfge := _aad.PopNumberAsFloat64()
	if _gfge != nil {
		return _gfge
	}
	_ccb, _gfge := _aad.PopNumberAsFloat64()
	if _gfge != nil {
		return _gfge
	}
	if _ba.Abs(_ccb-_ddce) < _gc {
		_ebd := _aad.Push(MakeBool(true))
		return _ebd
	} else if _ccb < _ddce {
		_egaa := _aad.Push(MakeBool(true))
		return _egaa
	} else {
		_ecab := _aad.Push(MakeBool(false))
		return _ecab
	}
}
func (_ca *PSReal) Duplicate() PSObject { _gcc := PSReal{}; _gcc.Val = _ca.Val; return &_gcc }

// Push pushes an object on top of the stack.
func (_dccd *PSStack) Push(obj PSObject) error {
	if len(*_dccd) > 100 {
		return ErrStackOverflow
	}
	*_dccd = append(*_dccd, obj)
	return nil
}

// Exec executes the operand `op` in the state specified by `stack`.
func (_fb *PSOperand) Exec(stack *PSStack) error {
	_fd := ErrUnsupportedOperand
	switch *_fb {
	case "\u0061\u0062\u0073":
		_fd = _fb.abs(stack)
	case "\u0061\u0064\u0064":
		_fd = _fb.add(stack)
	case "\u0061\u006e\u0064":
		_fd = _fb.and(stack)
	case "\u0061\u0074\u0061\u006e":
		_fd = _fb.atan(stack)
	case "\u0062\u0069\u0074\u0073\u0068\u0069\u0066\u0074":
		_fd = _fb.bitshift(stack)
	case "\u0063e\u0069\u006c\u0069\u006e\u0067":
		_fd = _fb.ceiling(stack)
	case "\u0063\u006f\u0070\u0079":
		_fd = _fb.copy(stack)
	case "\u0063\u006f\u0073":
		_fd = _fb.cos(stack)
	case "\u0063\u0076\u0069":
		_fd = _fb.cvi(stack)
	case "\u0063\u0076\u0072":
		_fd = _fb.cvr(stack)
	case "\u0064\u0069\u0076":
		_fd = _fb.div(stack)
	case "\u0064\u0075\u0070":
		_fd = _fb.dup(stack)
	case "\u0065\u0071":
		_fd = _fb.eq(stack)
	case "\u0065\u0078\u0063\u0068":
		_fd = _fb.exch(stack)
	case "\u0065\u0078\u0070":
		_fd = _fb.exp(stack)
	case "\u0066\u006c\u006fo\u0072":
		_fd = _fb.floor(stack)
	case "\u0067\u0065":
		_fd = _fb.ge(stack)
	case "\u0067\u0074":
		_fd = _fb.gt(stack)
	case "\u0069\u0064\u0069\u0076":
		_fd = _fb.idiv(stack)
	case "\u0069\u0066":
		_fd = _fb.ifCondition(stack)
	case "\u0069\u0066\u0065\u006c\u0073\u0065":
		_fd = _fb.ifelse(stack)
	case "\u0069\u006e\u0064e\u0078":
		_fd = _fb.index(stack)
	case "\u006c\u0065":
		_fd = _fb.le(stack)
	case "\u006c\u006f\u0067":
		_fd = _fb.log(stack)
	case "\u006c\u006e":
		_fd = _fb.ln(stack)
	case "\u006c\u0074":
		_fd = _fb.lt(stack)
	case "\u006d\u006f\u0064":
		_fd = _fb.mod(stack)
	case "\u006d\u0075\u006c":
		_fd = _fb.mul(stack)
	case "\u006e\u0065":
		_fd = _fb.ne(stack)
	case "\u006e\u0065\u0067":
		_fd = _fb.neg(stack)
	case "\u006e\u006f\u0074":
		_fd = _fb.not(stack)
	case "\u006f\u0072":
		_fd = _fb.or(stack)
	case "\u0070\u006f\u0070":
		_fd = _fb.pop(stack)
	case "\u0072\u006f\u0075n\u0064":
		_fd = _fb.round(stack)
	case "\u0072\u006f\u006c\u006c":
		_fd = _fb.roll(stack)
	case "\u0073\u0069\u006e":
		_fd = _fb.sin(stack)
	case "\u0073\u0071\u0072\u0074":
		_fd = _fb.sqrt(stack)
	case "\u0073\u0075\u0062":
		_fd = _fb.sub(stack)
	case "\u0074\u0072\u0075\u006e\u0063\u0061\u0074\u0065":
		_fd = _fb.truncate(stack)
	case "\u0078\u006f\u0072":
		_fd = _fb.xor(stack)
	}
	return _fd
}
func (_eba *PSOperand) exp(_dbf *PSStack) error {
	_ddf, _fce := _dbf.PopNumberAsFloat64()
	if _fce != nil {
		return _fce
	}
	_cgc, _fce := _dbf.PopNumberAsFloat64()
	if _fce != nil {
		return _fce
	}
	if _ba.Abs(_ddf) < 1 && _cgc < 0 {
		return ErrUndefinedResult
	}
	_cdb := _ba.Pow(_cgc, _ddf)
	_fce = _dbf.Push(MakeReal(_cdb))
	return _fce
}
func (_bae *PSOperand) copy(_ded *PSStack) error {
	_efb, _baa := _ded.PopInteger()
	if _baa != nil {
		return _baa
	}
	if _efb < 0 {
		return ErrRangeCheck
	}
	if _efb > len(*_ded) {
		return ErrRangeCheck
	}
	*_ded = append(*_ded, (*_ded)[len(*_ded)-_efb:]...)
	return nil
}
func (_bg *PSOperand) cos(_eee *PSStack) error {
	_ged, _cab := _eee.PopNumberAsFloat64()
	if _cab != nil {
		return _cab
	}
	_fdbg := _ba.Cos(_ged * _ba.Pi / 180.0)
	_cab = _eee.Push(MakeReal(_fdbg))
	return _cab
}

// MakeInteger returns a new PSInteger object initialized with `val`.
func MakeInteger(val int) *PSInteger { _gabf := PSInteger{}; _gabf.Val = val; return &_gabf }

// PSInteger represents an integer.
type PSInteger struct{ Val int }

// Pop pops an object from the top of the stack.
func (_debb *PSStack) Pop() (PSObject, error) {
	if len(*_debb) < 1 {
		return nil, ErrStackUnderflow
	}
	_bgdec := (*_debb)[len(*_debb)-1]
	*_debb = (*_debb)[0 : len(*_debb)-1]
	return _bgdec, nil
}
func (_afb *PSOperand) add(_afbf *PSStack) error {
	_gdg, _efc := _afbf.Pop()
	if _efc != nil {
		return _efc
	}
	_egf, _efc := _afbf.Pop()
	if _efc != nil {
		return _efc
	}
	_cd, _aa := _gdg.(*PSReal)
	_bf, _efd := _gdg.(*PSInteger)
	if !_aa && !_efd {
		return ErrTypeCheck
	}
	_gaf, _dcb := _egf.(*PSReal)
	_gfg, _gee := _egf.(*PSInteger)
	if !_dcb && !_gee {
		return ErrTypeCheck
	}
	if _efd && _gee {
		_fdb := _bf.Val + _gfg.Val
		_bff := _afbf.Push(MakeInteger(_fdb))
		return _bff
	}
	var _egg float64
	if _aa {
		_egg = _cd.Val
	} else {
		_egg = float64(_bf.Val)
	}
	if _dcb {
		_egg += _gaf.Val
	} else {
		_egg += float64(_gfg.Val)
	}
	_efc = _afbf.Push(MakeReal(_egg))
	return _efc
}
func (_ebcg *PSOperand) ge(_dca *PSStack) error {
	_adb, _effg := _dca.PopNumberAsFloat64()
	if _effg != nil {
		return _effg
	}
	_bga, _effg := _dca.PopNumberAsFloat64()
	if _effg != nil {
		return _effg
	}
	if _ba.Abs(_bga-_adb) < _gc {
		_gca := _dca.Push(MakeBool(true))
		return _gca
	} else if _bga > _adb {
		_fccg := _dca.Push(MakeBool(true))
		return _fccg
	} else {
		_fge := _dca.Push(MakeBool(false))
		return _fge
	}
}

var ErrRangeCheck = _b.New("\u0072\u0061\u006e\u0067\u0065\u0020\u0063\u0068\u0065\u0063\u006b\u0020e\u0072\u0072\u006f\u0072")

func (_bdb *PSOperand) floor(_acac *PSStack) error {
	_aba, _gga := _acac.Pop()
	if _gga != nil {
		return _gga
	}
	if _fffa, _fcd := _aba.(*PSReal); _fcd {
		_gga = _acac.Push(MakeReal(_ba.Floor(_fffa.Val)))
	} else if _cda, _cae := _aba.(*PSInteger); _cae {
		_gga = _acac.Push(MakeInteger(_cda.Val))
	} else {
		return ErrTypeCheck
	}
	return _gga
}

var ErrUnsupportedOperand = _b.New("\u0075\u006e\u0073\u0075pp\u006f\u0072\u0074\u0065\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064")

func (_aedb *PSOperand) sub(_cea *PSStack) error {
	_agfc, _fbg := _cea.Pop()
	if _fbg != nil {
		return _fbg
	}
	_cgg, _fbg := _cea.Pop()
	if _fbg != nil {
		return _fbg
	}
	_edad, _add := _agfc.(*PSReal)
	_fbgd, _fbbg := _agfc.(*PSInteger)
	if !_add && !_fbbg {
		return ErrTypeCheck
	}
	_bddc, _fddba := _cgg.(*PSReal)
	_dbb, _cdbe := _cgg.(*PSInteger)
	if !_fddba && !_cdbe {
		return ErrTypeCheck
	}
	if _fbbg && _cdbe {
		_ebga := _dbb.Val - _fbgd.Val
		_edgf := _cea.Push(MakeInteger(_ebga))
		return _edgf
	}
	var _fcdg float64 = 0
	if _fddba {
		_fcdg = _bddc.Val
	} else {
		_fcdg = float64(_dbb.Val)
	}
	if _add {
		_fcdg -= _edad.Val
	} else {
		_fcdg -= float64(_fbgd.Val)
	}
	_fbg = _cea.Push(MakeReal(_fcdg))
	return _fbg
}
func (_gd *PSBoolean) Duplicate() PSObject { _gdf := PSBoolean{}; _gdf.Val = _gd.Val; return &_gdf }

// PSObject represents a postscript object.
type PSObject interface {

	// Duplicate makes a fresh copy of the PSObject.
	Duplicate() PSObject

	// DebugString returns a descriptive representation of the PSObject with more information than String()
	// for debugging purposes.
	DebugString() string

	// String returns a string representation of the PSObject.
	String() string
}

func (_faed *PSParser) parseFunction() (*PSProgram, error) {
	_agc, _ := _faed._dddb.ReadByte()
	if _agc != '{' {
		return nil, _b.New("\u0069\u006ev\u0061\u006c\u0069d\u0020\u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e")
	}
	_efea := NewPSProgram()
	for {
		_faed.skipSpaces()
		_ccccb, _bgg := _faed._dddb.Peek(2)
		if _bgg != nil {
			if _bgg == _a.EOF {
				break
			}
			return nil, _bgg
		}
		_c.Log.Trace("\u0050e\u0065k\u0020\u0073\u0074\u0072\u0069\u006e\u0067\u003a\u0020\u0025\u0073", string(_ccccb))
		if _ccccb[0] == '}' {
			_c.Log.Trace("\u0045\u004f\u0046 \u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e")
			_faed._dddb.ReadByte()
			break
		} else if _ccccb[0] == '{' {
			_c.Log.Trace("\u0046u\u006e\u0063\u0074\u0069\u006f\u006e!")
			_fda, _aace := _faed.parseFunction()
			if _aace != nil {
				return nil, _aace
			}
			_efea.Append(_fda)
		} else if _d.IsDecimalDigit(_ccccb[0]) || (_ccccb[0] == '-' && _d.IsDecimalDigit(_ccccb[1])) {
			_c.Log.Trace("\u002d>\u004e\u0075\u006d\u0062\u0065\u0072!")
			_cge, _cfb := _faed.parseNumber()
			if _cfb != nil {
				return nil, _cfb
			}
			_efea.Append(_cge)
		} else {
			_c.Log.Trace("\u002d>\u004fp\u0065\u0072\u0061\u006e\u0064 \u006f\u0072 \u0062\u006f\u006f\u006c\u003f")
			_ccccb, _ = _faed._dddb.Peek(5)
			_aegg := string(_ccccb)
			_c.Log.Trace("\u0050\u0065\u0065k\u0020\u0073\u0074\u0072\u003a\u0020\u0025\u0073", _aegg)
			if (len(_aegg) > 4) && (_aegg[:5] == "\u0066\u0061\u006cs\u0065") {
				_gdc, _cgdd := _faed.parseBool()
				if _cgdd != nil {
					return nil, _cgdd
				}
				_efea.Append(_gdc)
			} else if (len(_aegg) > 3) && (_aegg[:4] == "\u0074\u0072\u0075\u0065") {
				_cdcb, _gdgb := _faed.parseBool()
				if _gdgb != nil {
					return nil, _gdgb
				}
				_efea.Append(_cdcb)
			} else {
				_fac, _faeb := _faed.parseOperand()
				if _faeb != nil {
					return nil, _faeb
				}
				_efea.Append(_fac)
			}
		}
	}
	return _efea, nil
}
func (_beb *PSOperand) roll(_fdc *PSStack) error {
	_adba, _beff := _fdc.Pop()
	if _beff != nil {
		return _beff
	}
	_ege, _beff := _fdc.Pop()
	if _beff != nil {
		return _beff
	}
	_fddb, _gbcd := _adba.(*PSInteger)
	if !_gbcd {
		return ErrTypeCheck
	}
	_aed, _gbcd := _ege.(*PSInteger)
	if !_gbcd {
		return ErrTypeCheck
	}
	if _aed.Val < 0 {
		return ErrRangeCheck
	}
	if _aed.Val == 0 || _aed.Val == 1 {
		return nil
	}
	if _aed.Val > len(*_fdc) {
		return ErrStackUnderflow
	}
	for _ecbd := 0; _ecbd < _fdg(_fddb.Val); _ecbd++ {
		var _ebac []PSObject
		_ebac = (*_fdc)[len(*_fdc)-(_aed.Val) : len(*_fdc)]
		if _fddb.Val > 0 {
			_edef := _ebac[len(_ebac)-1]
			_ebac = append([]PSObject{_edef}, _ebac[0:len(_ebac)-1]...)
		} else {
			_baf := _ebac[len(_ebac)-_aed.Val]
			_ebac = append(_ebac[1:], _baf)
		}
		_cgaa := append((*_fdc)[0:len(*_fdc)-_aed.Val], _ebac...)
		_fdc = &_cgaa
	}
	return nil
}
func (_cfff *PSOperand) log(_dbee *PSStack) error {
	_bfe, _cfd := _dbee.PopNumberAsFloat64()
	if _cfd != nil {
		return _cfd
	}
	_dfbg := _ba.Log10(_bfe)
	_cfd = _dbee.Push(MakeReal(_dfbg))
	return _cfd
}
func (_bdeg *PSOperand) div(_ffc *PSStack) error {
	_gge, _edg := _ffc.Pop()
	if _edg != nil {
		return _edg
	}
	_cde, _edg := _ffc.Pop()
	if _edg != nil {
		return _edg
	}
	_ccc, _gaa := _gge.(*PSReal)
	_efce, _cccc := _gge.(*PSInteger)
	if !_gaa && !_cccc {
		return ErrTypeCheck
	}
	if _gaa && _ccc.Val == 0 {
		return ErrUndefinedResult
	}
	if _cccc && _efce.Val == 0 {
		return ErrUndefinedResult
	}
	_ddg, _gef := _cde.(*PSReal)
	_bgd, _faa := _cde.(*PSInteger)
	if !_gef && !_faa {
		return ErrTypeCheck
	}
	var _cf float64
	if _gef {
		_cf = _ddg.Val
	} else {
		_cf = float64(_bgd.Val)
	}
	if _gaa {
		_cf /= _ccc.Val
	} else {
		_cf /= float64(_efce.Val)
	}
	_edg = _ffc.Push(MakeReal(_cf))
	return _edg
}

// MakeOperand returns a new PSOperand object based on string `val`.
func MakeOperand(val string) *PSOperand { _gcdd := PSOperand(val); return &_gcdd }
func (_adfg *PSOperand) sqrt(_bfb *PSStack) error {
	_ece, _bbb := _bfb.PopNumberAsFloat64()
	if _bbb != nil {
		return _bbb
	}
	if _ece < 0 {
		return ErrRangeCheck
	}
	_bfg := _ba.Sqrt(_ece)
	_bbb = _bfb.Push(MakeReal(_bfg))
	return _bbb
}

// DebugString returns a descriptive string representation of the stack - intended for debugging.
func (_cgcc *PSStack) DebugString() string {
	_ccbf := "\u005b\u0020"
	for _, _ggee := range *_cgcc {
		_ccbf += _ggee.DebugString()
		_ccbf += "\u0020"
	}
	_ccbf += "\u005d"
	return _ccbf
}
func (_aecf *PSOperand) ifelse(_cga *PSStack) error {
	_gea, _bfa := _cga.Pop()
	if _bfa != nil {
		return _bfa
	}
	_debc, _bfa := _cga.Pop()
	if _bfa != nil {
		return _bfa
	}
	_fbe, _bfa := _cga.Pop()
	if _bfa != nil {
		return _bfa
	}
	_bab, _dba := _gea.(*PSProgram)
	if !_dba {
		return ErrTypeCheck
	}
	_fgac, _dba := _debc.(*PSProgram)
	if !_dba {
		return ErrTypeCheck
	}
	_ead, _dba := _fbe.(*PSBoolean)
	if !_dba {
		return ErrTypeCheck
	}
	if _ead.Val {
		_bffa := _fgac.Exec(_cga)
		return _bffa
	}
	_bfa = _bab.Exec(_cga)
	return _bfa
}
func (_da *PSOperand) ceiling(_eeg *PSStack) error {
	_eed, _dec := _eeg.Pop()
	if _dec != nil {
		return _dec
	}
	if _agafa, _dga := _eed.(*PSReal); _dga {
		_dec = _eeg.Push(MakeReal(_ba.Ceil(_agafa.Val)))
	} else if _agaa, _fbc := _eed.(*PSInteger); _fbc {
		_dec = _eeg.Push(MakeInteger(_agaa.Val))
	} else {
		_dec = ErrTypeCheck
	}
	return _dec
}