Error(s) in re-building vignettes:
  ...
--- re-building ‘intro.Rnw’ using Sweave
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
--- finished re-building ‘intro.Rnw’

--- re-building ‘overview.Rnw’ using Sweave
Loading required package: GPArotation
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used

  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used

  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Loading required namespace: sem
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used

Error: processing vignette 'overview.Rnw' failed with diagnostics:
 chunk 41 
Error in fa.sort(f) : object ‘factors’ not found

--- failed re-building ‘overview.Rnw’

--- re-building ‘psych_for_sem.Rnw’ using Sweave
Loading required package: sem
Loading required package: GPArotation
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(p.loading) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(phi.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Loading required namespace: lavaan
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(R.inv) == as.character("try-error")) { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(m.inv.r) == "try-error") { :
  the condition has length > 1 and only the first element will be used
Warning in if (class(w) == "try-error") { :
  the condition has length > 1 and only the first element will be used
--- finished re-building ‘psych_for_sem.Rnw’

SUMMARY: processing the following file failed:
  ‘overview.Rnw’

Error: Vignette re-building failed.
Execution halted