locale.generated.go

// CODE GENERATED BY lang.js. DO NOT MODIFY
package header

import "strings"

// GetI18n returns the value by its locale
func GetI18n(str *I18NString, locale, fallback string) string {
	if str == nil {
		return fallback
	}
	if locale == "af-NA" {
		if str.Af_NA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Af_NA
	}

	if locale == "af-ZA" {
		if str.Af_ZA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Af_ZA
	}

	if locale == "ar-AR" {
		if str.Ar_AR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ar_AR
	}

	if locale == "ar-MA" {
		if str.Ar_MA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ar_MA
	}

	if locale == "ar-SA" {
		if str.Ar_SA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ar_SA
	}

	if locale == "ay-BO" {
		if str.Ay_BO == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ay_BO
	}

	if locale == "az-AZ" {
		if str.Az_AZ == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Az_AZ
	}

	if locale == "be-BY" {
		if str.Be_BY == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Be_BY
	}

	if locale == "bg-BG" {
		if str.Bg_BG == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Bg_BG
	}

	if locale == "bn-IN" {
		if str.Bn_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Bn_IN
	}

	if locale == "bn-BD" {
		if str.Bn_BD == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Bn_BD
	}

	if locale == "bs-BA" {
		if str.Bs_BA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Bs_BA
	}

	if locale == "ca-ES" {
		if str.Ca_ES == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ca_ES
	}

	if locale == "ck-US" {
		if str.Ck_US == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ck_US
	}

	if locale == "cs-CZ" {
		if str.Cs_CZ == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Cs_CZ
	}

	if locale == "cy-GB" {
		if str.Cy_GB == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Cy_GB
	}

	if locale == "da-DK" {
		if str.Da_DK == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Da_DK
	}

	if locale == "de-AT" {
		if str.De_AT == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.De_AT
	}

	if locale == "de-DE" {
		if str.De_DE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.De_DE
	}

	if locale == "de-CH" {
		if str.De_CH == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.De_CH
	}

	if locale == "el-GR" {
		if str.El_GR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.El_GR
	}

	if locale == "en-GB" {
		if str.En_GB == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_GB
	}

	if locale == "en-AU" {
		if str.En_AU == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_AU
	}

	if locale == "en-CA" {
		if str.En_CA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_CA
	}

	if locale == "en-IE" {
		if str.En_IE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_IE
	}

	if locale == "en-IN" {
		if str.En_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_IN
	}

	if locale == "en-PI" {
		if str.En_PI == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_PI
	}

	if locale == "en-UD" {
		if str.En_UD == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_UD
	}

	if locale == "en-US" {
		if str.En_US == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_US
	}

	if locale == "en-ZA" {
		if str.En_ZA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_ZA
	}

	if locale == "eo-EO" {
		if str.Eo_EO == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Eo_EO
	}

	if locale == "es-AR" {
		if str.Es_AR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_AR
	}

	if locale == "es-419" {
		if str.Es_419 == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_419
	}

	if locale == "es-CL" {
		if str.Es_CL == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_CL
	}

	if locale == "es-CO" {
		if str.Es_CO == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_CO
	}

	if locale == "es-EC" {
		if str.Es_EC == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_EC
	}

	if locale == "es-ES" {
		if str.Es_ES == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_ES
	}

	if locale == "es-LA" {
		if str.Es_LA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_LA
	}

	if locale == "es-NI" {
		if str.Es_NI == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_NI
	}

	if locale == "es-MX" {
		if str.Es_MX == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_MX
	}

	if locale == "es-US" {
		if str.Es_US == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_US
	}

	if locale == "es-VE" {
		if str.Es_VE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Es_VE
	}

	if locale == "et-EE" {
		if str.Et_EE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Et_EE
	}

	if locale == "eu-ES" {
		if str.Eu_ES == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Eu_ES
	}

	if locale == "fa-IR" {
		if str.Fa_IR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Fa_IR
	}

	if locale == "fb-LT" {
		if str.Fb_LT == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Fb_LT
	}

	if locale == "fi-FI" {
		if str.Fi_FI == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Fi_FI
	}

	if locale == "fo-FO" {
		if str.Fo_FO == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Fo_FO
	}

	if locale == "fr-CA" {
		if str.Fr_CA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Fr_CA
	}

	if locale == "fr-FR" {
		if str.Fr_FR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Fr_FR
	}

	if locale == "fr-BE" {
		if str.Fr_BE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Fr_BE
	}

	if locale == "fr-CH" {
		if str.Fr_CH == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Fr_CH
	}

	if locale == "fy-NL" {
		if str.Fy_NL == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Fy_NL
	}

	if locale == "ga-IE" {
		if str.Ga_IE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ga_IE
	}

	if locale == "gl-ES" {
		if str.Gl_ES == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Gl_ES
	}

	if locale == "gn-PY" {
		if str.Gn_PY == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Gn_PY
	}

	if locale == "gu-IN" {
		if str.Gu_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Gu_IN
	}

	if locale == "gx-GR" {
		if str.Gx_GR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Gx_GR
	}

	if locale == "he-IL" {
		if str.He_IL == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.He_IL
	}

	if locale == "hi-IN" {
		if str.Hi_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Hi_IN
	}

	if locale == "hr-HR" {
		if str.Hr_HR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Hr_HR
	}

	if locale == "hu-HU" {
		if str.Hu_HU == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Hu_HU
	}

	if locale == "hy-AM" {
		if str.Hy_AM == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Hy_AM
	}

	if locale == "id-ID" {
		if str.Id_ID == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Id_ID
	}

	if locale == "is-IS" {
		if str.Is_IS == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Is_IS
	}

	if locale == "it-IT" {
		if str.It_IT == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.It_IT
	}

	if locale == "ja-JP" {
		if str.Ja_JP == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ja_JP
	}

	if locale == "jv-ID" {
		if str.Jv_ID == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Jv_ID
	}

	if locale == "ka-GE" {
		if str.Ka_GE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ka_GE
	}

	if locale == "kk-KZ" {
		if str.Kk_KZ == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Kk_KZ
	}

	if locale == "km-KH" {
		if str.Km_KH == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Km_KH
	}

	if locale == "kn-IN" {
		if str.Kn_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Kn_IN
	}

	if locale == "ko-KR" {
		if str.Ko_KR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ko_KR
	}

	if locale == "ku-TR" {
		if str.Ku_TR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ku_TR
	}

	if locale == "la-VA" {
		if str.La_VA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.La_VA
	}

	if locale == "li-NL" {
		if str.Li_NL == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Li_NL
	}

	if locale == "lt-LT" {
		if str.Lt_LT == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Lt_LT
	}

	if locale == "lv-LV" {
		if str.Lv_LV == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Lv_LV
	}

	if locale == "mg-MG" {
		if str.Mg_MG == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Mg_MG
	}

	if locale == "mk-MK" {
		if str.Mk_MK == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Mk_MK
	}

	if locale == "ml-IN" {
		if str.Ml_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ml_IN
	}

	if locale == "mn-MN" {
		if str.Mn_MN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Mn_MN
	}

	if locale == "mr-IN" {
		if str.Mr_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Mr_IN
	}

	if locale == "ms-MY" {
		if str.Ms_MY == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ms_MY
	}

	if locale == "mt-MT" {
		if str.Mt_MT == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Mt_MT
	}

	if locale == "nb-NO" {
		if str.Nb_NO == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Nb_NO
	}

	if locale == "ne-NP" {
		if str.Ne_NP == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ne_NP
	}

	if locale == "nl-BE" {
		if str.Nl_BE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Nl_BE
	}

	if locale == "nl-NL" {
		if str.Nl_NL == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Nl_NL
	}

	if locale == "nn-NO" {
		if str.Nn_NO == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Nn_NO
	}

	if locale == "or-IN" {
		if str.Or_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Or_IN
	}

	if locale == "pa-IN" {
		if str.Pa_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Pa_IN
	}

	if locale == "pl-PL" {
		if str.Pl_PL == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Pl_PL
	}

	if locale == "ps-AF" {
		if str.Ps_AF == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ps_AF
	}

	if locale == "pt-BR" {
		if str.Pt_BR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Pt_BR
	}

	if locale == "pt-PT" {
		if str.Pt_PT == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Pt_PT
	}

	if locale == "qu-PE" {
		if str.Qu_PE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Qu_PE
	}

	if locale == "rm-CH" {
		if str.Rm_CH == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Rm_CH
	}

	if locale == "ro-RO" {
		if str.Ro_RO == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ro_RO
	}

	if locale == "ru-RU" {
		if str.Ru_RU == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ru_RU
	}

	if locale == "sa-IN" {
		if str.Sa_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Sa_IN
	}

	if locale == "se-NO" {
		if str.Se_NO == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Se_NO
	}

	if locale == "si-LK" {
		if str.Si_LK == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Si_LK
	}

	if locale == "sk-SK" {
		if str.Sk_SK == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Sk_SK
	}

	if locale == "sl-SI" {
		if str.Sl_SI == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Sl_SI
	}

	if locale == "so-SO" {
		if str.So_SO == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.So_SO
	}

	if locale == "sq-AL" {
		if str.Sq_AL == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Sq_AL
	}

	if locale == "sr-RS" {
		if str.Sr_RS == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Sr_RS
	}

	if locale == "sv-SE" {
		if str.Sv_SE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Sv_SE
	}

	if locale == "sw-KE" {
		if str.Sw_KE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Sw_KE
	}

	if locale == "ta-IN" {
		if str.Ta_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ta_IN
	}

	if locale == "te-IN" {
		if str.Te_IN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Te_IN
	}

	if locale == "tg-TJ" {
		if str.Tg_TJ == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Tg_TJ
	}

	if locale == "th-TH" {
		if str.Th_TH == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Th_TH
	}

	if locale == "tl-PH" {
		if str.Tl_PH == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Tl_PH
	}

	if locale == "tr-TR" {
		if str.Tr_TR == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Tr_TR
	}

	if locale == "tt-RU" {
		if str.Tt_RU == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Tt_RU
	}

	if locale == "uk-UA" {
		if str.Uk_UA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Uk_UA
	}

	if locale == "ur-PK" {
		if str.Ur_PK == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Ur_PK
	}

	if locale == "uz-UZ" {
		if str.Uz_UZ == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Uz_UZ
	}

	if locale == "vi-VN" {
		if str.Vi_VN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Vi_VN
	}

	if locale == "xh-ZA" {
		if str.Xh_ZA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Xh_ZA
	}

	if locale == "yi-DE" {
		if str.Yi_DE == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Yi_DE
	}

	if locale == "zh-Hans" {
		if str.Zh_Hans == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Zh_Hans
	}

	if locale == "zh-Hant" {
		if str.Zh_Hant == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Zh_Hant
	}

	if locale == "zh-CN" {
		if str.Zh_CN == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Zh_CN
	}

	if locale == "zh-HK" {
		if str.Zh_HK == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Zh_HK
	}

	if locale == "zh-SG" {
		if str.Zh_SG == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Zh_SG
	}

	if locale == "zh-TW" {
		if str.Zh_TW == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Zh_TW
	}

	if locale == "zu-ZA" {
		if str.Zu_ZA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Zu_ZA
	}

	if locale == "lo-LA" {
		if str.Lo_LA == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Lo_LA
	}

	if locale == "aa-ER" {
		if str.Aa_ER == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.Aa_ER
	}

	if locale == "en-SG" {
		if str.En_SG == "" && fallback != locale && fallback != "" {
			return GetI18n(str, fallback, fallback)
		}
		return str.En_SG
	}

	return fallback
}
var LocaleM = map[string]bool{
	"af-NA": true,
	"af-ZA": true,
	"ar-AR": true,
	"ar-MA": true,
	"ar-SA": true,
	"ay-BO": true,
	"az-AZ": true,
	"be-BY": true,
	"bg-BG": true,
	"bn-IN": true,
	"bn-BD": true,
	"bs-BA": true,
	"ca-ES": true,
	"ck-US": true,
	"cs-CZ": true,
	"cy-GB": true,
	"da-DK": true,
	"de-AT": true,
	"de-DE": true,
	"de-CH": true,
	"el-GR": true,
	"en-GB": true,
	"en-AU": true,
	"en-CA": true,
	"en-IE": true,
	"en-IN": true,
	"en-PI": true,
	"en-UD": true,
	"en-US": true,
	"en-ZA": true,
	"eo-EO": true,
	"es-AR": true,
	"es-419": true,
	"es-CL": true,
	"es-CO": true,
	"es-EC": true,
	"es-ES": true,
	"es-LA": true,
	"es-NI": true,
	"es-MX": true,
	"es-US": true,
	"es-VE": true,
	"et-EE": true,
	"eu-ES": true,
	"fa-IR": true,
	"fb-LT": true,
	"fi-FI": true,
	"fo-FO": true,
	"fr-CA": true,
	"fr-FR": true,
	"fr-BE": true,
	"fr-CH": true,
	"fy-NL": true,
	"ga-IE": true,
	"gl-ES": true,
	"gn-PY": true,
	"gu-IN": true,
	"gx-GR": true,
	"he-IL": true,
	"hi-IN": true,
	"hr-HR": true,
	"hu-HU": true,
	"hy-AM": true,
	"id-ID": true,
	"is-IS": true,
	"it-IT": true,
	"ja-JP": true,
	"jv-ID": true,
	"ka-GE": true,
	"kk-KZ": true,
	"km-KH": true,
	"kn-IN": true,
	"ko-KR": true,
	"ku-TR": true,
	"la-VA": true,
	"li-NL": true,
	"lt-LT": true,
	"lv-LV": true,
	"mg-MG": true,
	"mk-MK": true,
	"ml-IN": true,
	"mn-MN": true,
	"mr-IN": true,
	"ms-MY": true,
	"mt-MT": true,
	"nb-NO": true,
	"ne-NP": true,
	"nl-BE": true,
	"nl-NL": true,
	"nn-NO": true,
	"or-IN": true,
	"pa-IN": true,
	"pl-PL": true,
	"ps-AF": true,
	"pt-BR": true,
	"pt-PT": true,
	"qu-PE": true,
	"rm-CH": true,
	"ro-RO": true,
	"ru-RU": true,
	"sa-IN": true,
	"se-NO": true,
	"si-LK": true,
	"sk-SK": true,
	"sl-SI": true,
	"so-SO": true,
	"sq-AL": true,
	"sr-RS": true,
	"sv-SE": true,
	"sw-KE": true,
	"ta-IN": true,
	"te-IN": true,
	"tg-TJ": true,
	"th-TH": true,
	"tl-PH": true,
	"tr-TR": true,
	"tt-RU": true,
	"uk-UA": true,
	"ur-PK": true,
	"uz-UZ": true,
	"vi-VN": true,
	"xh-ZA": true,
	"yi-DE": true,
	"zh-Hans": true,
	"zh-Hant": true,
	"zh-CN": true,
	"zh-HK": true,
	"zh-SG": true,
	"zh-TW": true,
	"zu-ZA": true,
	"lo-LA": true,
	"aa-ER": true,
	"en-SG": true,
}

var AllCurrency = map[string]bool{
	"AFN": true,
	"EUR": true,
	"ALL": true,
	"DZD": true,
	"USD": true,
	"AOA": true,
	"XCD": true,
	"ARS": true,
	"AMD": true,
	"AWG": true,
	"AUD": true,
	"AZN": true,
	"BSD": true,
	"BHD": true,
	"BDT": true,
	"BBD": true,
	"BYN": true,
	"BZD": true,
	"XOF": true,
	"BMD": true,
	"INR": true,
	"BTN": true,
	"BOB": true,
	"BOV": true,
	"BAM": true,
	"BWP": true,
	"NOK": true,
	"BRL": true,
	"BND": true,
	"BGN": true,
	"BIF": true,
	"CVE": true,
	"KHR": true,
	"XAF": true,
	"CAD": true,
	"KYD": true,
	"CLP": true,
	"CLF": true,
	"CNY": true,
	"COP": true,
	"COU": true,
	"KMF": true,
	"CDF": true,
	"NZD": true,
	"CRC": true,
	"HRK": true,
	"CUP": true,
	"CUC": true,
	"ANG": true,
	"CZK": true,
	"DKK": true,
	"DJF": true,
	"DOP": true,
	"EGP": true,
	"SVC": true,
	"ERN": true,
	"SZL": true,
	"ETB": true,
	"FKP": true,
	"FJD": true,
	"XPF": true,
	"GMD": true,
	"GEL": true,
	"GHS": true,
	"GIP": true,
	"GTQ": true,
	"GBP": true,
	"GNF": true,
	"GYD": true,
	"HTG": true,
	"HNL": true,
	"HKD": true,
	"HUF": true,
	"ISK": true,
	"IDR": true,
	"XDR": true,
	"IRR": true,
	"IQD": true,
	"ILS": true,
	"JMD": true,
	"JPY": true,
	"JOD": true,
	"KZT": true,
	"KES": true,
	"KPW": true,
	"KRW": true,
	"KWD": true,
	"KGS": true,
	"LAK": true,
	"LBP": true,
	"LSL": true,
	"ZAR": true,
	"LRD": true,
	"LYD": true,
	"CHF": true,
	"MOP": true,
	"MKD": true,
	"MGA": true,
	"MWK": true,
	"MYR": true,
	"MVR": true,
	"MRU": true,
	"MUR": true,
	"XUA": true,
	"MXN": true,
	"MXV": true,
	"MDL": true,
	"MNT": true,
	"MAD": true,
	"MZN": true,
	"MMK": true,
	"NAD": true,
	"NPR": true,
	"NIO": true,
	"NGN": true,
	"OMR": true,
	"PKR": true,
	"PAB": true,
	"PGK": true,
	"PYG": true,
	"PEN": true,
	"PHP": true,
	"PLN": true,
	"QAR": true,
	"RON": true,
	"RUB": true,
	"RWF": true,
	"SHP": true,
	"WST": true,
	"STN": true,
	"SAR": true,
	"RSD": true,
	"SCR": true,
	"SLL": true,
	"SGD": true,
	"XSU": true,
	"SBD": true,
	"SOS": true,
	"SSP": true,
	"LKR": true,
	"SDG": true,
	"SRD": true,
	"SEK": true,
	"CHE": true,
	"CHW": true,
	"SYP": true,
	"TWD": true,
	"TJS": true,
	"TZS": true,
	"THB": true,
	"TOP": true,
	"TTD": true,
	"TND": true,
	"TRY": true,
	"TMT": true,
	"UGX": true,
	"UAH": true,
	"AED": true,
	"USN": true,
	"UYU": true,
	"UYI": true,
	"UYW": true,
	"UZS": true,
	"VUV": true,
	"VES": true,
	"VED": true,
	"VND": true,
	"YER": true,
	"ZMW": true,
	"ZWL": true,
	"XBA": true,
	"XBB": true,
	"XBC": true,
	"XBD": true,
	"XTS": true,
	"XXX": true,
	"XAU": true,
	"XPD": true,
	"XPT": true,
	"XAG": true,
}


func GetAllI18ns(str *I18NString) []string {
	out := make([]string, 0)
	if strings.TrimSpace(str.Af_NA) != "" {
		out = append(out, str.Af_NA)
	}

	if strings.TrimSpace(str.Af_ZA) != "" {
		out = append(out, str.Af_ZA)
	}

	if strings.TrimSpace(str.Ar_AR) != "" {
		out = append(out, str.Ar_AR)
	}

	if strings.TrimSpace(str.Ar_MA) != "" {
		out = append(out, str.Ar_MA)
	}

	if strings.TrimSpace(str.Ar_SA) != "" {
		out = append(out, str.Ar_SA)
	}

	if strings.TrimSpace(str.Ay_BO) != "" {
		out = append(out, str.Ay_BO)
	}

	if strings.TrimSpace(str.Az_AZ) != "" {
		out = append(out, str.Az_AZ)
	}

	if strings.TrimSpace(str.Be_BY) != "" {
		out = append(out, str.Be_BY)
	}

	if strings.TrimSpace(str.Bg_BG) != "" {
		out = append(out, str.Bg_BG)
	}

	if strings.TrimSpace(str.Bn_IN) != "" {
		out = append(out, str.Bn_IN)
	}

	if strings.TrimSpace(str.Bn_BD) != "" {
		out = append(out, str.Bn_BD)
	}

	if strings.TrimSpace(str.Bs_BA) != "" {
		out = append(out, str.Bs_BA)
	}

	if strings.TrimSpace(str.Ca_ES) != "" {
		out = append(out, str.Ca_ES)
	}

	if strings.TrimSpace(str.Ck_US) != "" {
		out = append(out, str.Ck_US)
	}

	if strings.TrimSpace(str.Cs_CZ) != "" {
		out = append(out, str.Cs_CZ)
	}

	if strings.TrimSpace(str.Cy_GB) != "" {
		out = append(out, str.Cy_GB)
	}

	if strings.TrimSpace(str.Da_DK) != "" {
		out = append(out, str.Da_DK)
	}

	if strings.TrimSpace(str.De_AT) != "" {
		out = append(out, str.De_AT)
	}

	if strings.TrimSpace(str.De_DE) != "" {
		out = append(out, str.De_DE)
	}

	if strings.TrimSpace(str.De_CH) != "" {
		out = append(out, str.De_CH)
	}

	if strings.TrimSpace(str.El_GR) != "" {
		out = append(out, str.El_GR)
	}

	if strings.TrimSpace(str.En_GB) != "" {
		out = append(out, str.En_GB)
	}

	if strings.TrimSpace(str.En_AU) != "" {
		out = append(out, str.En_AU)
	}

	if strings.TrimSpace(str.En_CA) != "" {
		out = append(out, str.En_CA)
	}

	if strings.TrimSpace(str.En_IE) != "" {
		out = append(out, str.En_IE)
	}

	if strings.TrimSpace(str.En_IN) != "" {
		out = append(out, str.En_IN)
	}

	if strings.TrimSpace(str.En_PI) != "" {
		out = append(out, str.En_PI)
	}

	if strings.TrimSpace(str.En_UD) != "" {
		out = append(out, str.En_UD)
	}

	if strings.TrimSpace(str.En_US) != "" {
		out = append(out, str.En_US)
	}

	if strings.TrimSpace(str.En_ZA) != "" {
		out = append(out, str.En_ZA)
	}

	if strings.TrimSpace(str.Eo_EO) != "" {
		out = append(out, str.Eo_EO)
	}

	if strings.TrimSpace(str.Es_AR) != "" {
		out = append(out, str.Es_AR)
	}

	if strings.TrimSpace(str.Es_419) != "" {
		out = append(out, str.Es_419)
	}

	if strings.TrimSpace(str.Es_CL) != "" {
		out = append(out, str.Es_CL)
	}

	if strings.TrimSpace(str.Es_CO) != "" {
		out = append(out, str.Es_CO)
	}

	if strings.TrimSpace(str.Es_EC) != "" {
		out = append(out, str.Es_EC)
	}

	if strings.TrimSpace(str.Es_ES) != "" {
		out = append(out, str.Es_ES)
	}

	if strings.TrimSpace(str.Es_LA) != "" {
		out = append(out, str.Es_LA)
	}

	if strings.TrimSpace(str.Es_NI) != "" {
		out = append(out, str.Es_NI)
	}

	if strings.TrimSpace(str.Es_MX) != "" {
		out = append(out, str.Es_MX)
	}

	if strings.TrimSpace(str.Es_US) != "" {
		out = append(out, str.Es_US)
	}

	if strings.TrimSpace(str.Es_VE) != "" {
		out = append(out, str.Es_VE)
	}

	if strings.TrimSpace(str.Et_EE) != "" {
		out = append(out, str.Et_EE)
	}

	if strings.TrimSpace(str.Eu_ES) != "" {
		out = append(out, str.Eu_ES)
	}

	if strings.TrimSpace(str.Fa_IR) != "" {
		out = append(out, str.Fa_IR)
	}

	if strings.TrimSpace(str.Fb_LT) != "" {
		out = append(out, str.Fb_LT)
	}

	if strings.TrimSpace(str.Fi_FI) != "" {
		out = append(out, str.Fi_FI)
	}

	if strings.TrimSpace(str.Fo_FO) != "" {
		out = append(out, str.Fo_FO)
	}

	if strings.TrimSpace(str.Fr_CA) != "" {
		out = append(out, str.Fr_CA)
	}

	if strings.TrimSpace(str.Fr_FR) != "" {
		out = append(out, str.Fr_FR)
	}

	if strings.TrimSpace(str.Fr_BE) != "" {
		out = append(out, str.Fr_BE)
	}

	if strings.TrimSpace(str.Fr_CH) != "" {
		out = append(out, str.Fr_CH)
	}

	if strings.TrimSpace(str.Fy_NL) != "" {
		out = append(out, str.Fy_NL)
	}

	if strings.TrimSpace(str.Ga_IE) != "" {
		out = append(out, str.Ga_IE)
	}

	if strings.TrimSpace(str.Gl_ES) != "" {
		out = append(out, str.Gl_ES)
	}

	if strings.TrimSpace(str.Gn_PY) != "" {
		out = append(out, str.Gn_PY)
	}

	if strings.TrimSpace(str.Gu_IN) != "" {
		out = append(out, str.Gu_IN)
	}

	if strings.TrimSpace(str.Gx_GR) != "" {
		out = append(out, str.Gx_GR)
	}

	if strings.TrimSpace(str.He_IL) != "" {
		out = append(out, str.He_IL)
	}

	if strings.TrimSpace(str.Hi_IN) != "" {
		out = append(out, str.Hi_IN)
	}

	if strings.TrimSpace(str.Hr_HR) != "" {
		out = append(out, str.Hr_HR)
	}

	if strings.TrimSpace(str.Hu_HU) != "" {
		out = append(out, str.Hu_HU)
	}

	if strings.TrimSpace(str.Hy_AM) != "" {
		out = append(out, str.Hy_AM)
	}

	if strings.TrimSpace(str.Id_ID) != "" {
		out = append(out, str.Id_ID)
	}

	if strings.TrimSpace(str.Is_IS) != "" {
		out = append(out, str.Is_IS)
	}

	if strings.TrimSpace(str.It_IT) != "" {
		out = append(out, str.It_IT)
	}

	if strings.TrimSpace(str.Ja_JP) != "" {
		out = append(out, str.Ja_JP)
	}

	if strings.TrimSpace(str.Jv_ID) != "" {
		out = append(out, str.Jv_ID)
	}

	if strings.TrimSpace(str.Ka_GE) != "" {
		out = append(out, str.Ka_GE)
	}

	if strings.TrimSpace(str.Kk_KZ) != "" {
		out = append(out, str.Kk_KZ)
	}

	if strings.TrimSpace(str.Km_KH) != "" {
		out = append(out, str.Km_KH)
	}

	if strings.TrimSpace(str.Kn_IN) != "" {
		out = append(out, str.Kn_IN)
	}

	if strings.TrimSpace(str.Ko_KR) != "" {
		out = append(out, str.Ko_KR)
	}

	if strings.TrimSpace(str.Ku_TR) != "" {
		out = append(out, str.Ku_TR)
	}

	if strings.TrimSpace(str.La_VA) != "" {
		out = append(out, str.La_VA)
	}

	if strings.TrimSpace(str.Li_NL) != "" {
		out = append(out, str.Li_NL)
	}

	if strings.TrimSpace(str.Lt_LT) != "" {
		out = append(out, str.Lt_LT)
	}

	if strings.TrimSpace(str.Lv_LV) != "" {
		out = append(out, str.Lv_LV)
	}

	if strings.TrimSpace(str.Mg_MG) != "" {
		out = append(out, str.Mg_MG)
	}

	if strings.TrimSpace(str.Mk_MK) != "" {
		out = append(out, str.Mk_MK)
	}

	if strings.TrimSpace(str.Ml_IN) != "" {
		out = append(out, str.Ml_IN)
	}

	if strings.TrimSpace(str.Mn_MN) != "" {
		out = append(out, str.Mn_MN)
	}

	if strings.TrimSpace(str.Mr_IN) != "" {
		out = append(out, str.Mr_IN)
	}

	if strings.TrimSpace(str.Ms_MY) != "" {
		out = append(out, str.Ms_MY)
	}

	if strings.TrimSpace(str.Mt_MT) != "" {
		out = append(out, str.Mt_MT)
	}

	if strings.TrimSpace(str.Nb_NO) != "" {
		out = append(out, str.Nb_NO)
	}

	if strings.TrimSpace(str.Ne_NP) != "" {
		out = append(out, str.Ne_NP)
	}

	if strings.TrimSpace(str.Nl_BE) != "" {
		out = append(out, str.Nl_BE)
	}

	if strings.TrimSpace(str.Nl_NL) != "" {
		out = append(out, str.Nl_NL)
	}

	if strings.TrimSpace(str.Nn_NO) != "" {
		out = append(out, str.Nn_NO)
	}

	if strings.TrimSpace(str.Or_IN) != "" {
		out = append(out, str.Or_IN)
	}

	if strings.TrimSpace(str.Pa_IN) != "" {
		out = append(out, str.Pa_IN)
	}

	if strings.TrimSpace(str.Pl_PL) != "" {
		out = append(out, str.Pl_PL)
	}

	if strings.TrimSpace(str.Ps_AF) != "" {
		out = append(out, str.Ps_AF)
	}

	if strings.TrimSpace(str.Pt_BR) != "" {
		out = append(out, str.Pt_BR)
	}

	if strings.TrimSpace(str.Pt_PT) != "" {
		out = append(out, str.Pt_PT)
	}

	if strings.TrimSpace(str.Qu_PE) != "" {
		out = append(out, str.Qu_PE)
	}

	if strings.TrimSpace(str.Rm_CH) != "" {
		out = append(out, str.Rm_CH)
	}

	if strings.TrimSpace(str.Ro_RO) != "" {
		out = append(out, str.Ro_RO)
	}

	if strings.TrimSpace(str.Ru_RU) != "" {
		out = append(out, str.Ru_RU)
	}

	if strings.TrimSpace(str.Sa_IN) != "" {
		out = append(out, str.Sa_IN)
	}

	if strings.TrimSpace(str.Se_NO) != "" {
		out = append(out, str.Se_NO)
	}

	if strings.TrimSpace(str.Si_LK) != "" {
		out = append(out, str.Si_LK)
	}

	if strings.TrimSpace(str.Sk_SK) != "" {
		out = append(out, str.Sk_SK)
	}

	if strings.TrimSpace(str.Sl_SI) != "" {
		out = append(out, str.Sl_SI)
	}

	if strings.TrimSpace(str.So_SO) != "" {
		out = append(out, str.So_SO)
	}

	if strings.TrimSpace(str.Sq_AL) != "" {
		out = append(out, str.Sq_AL)
	}

	if strings.TrimSpace(str.Sr_RS) != "" {
		out = append(out, str.Sr_RS)
	}

	if strings.TrimSpace(str.Sv_SE) != "" {
		out = append(out, str.Sv_SE)
	}

	if strings.TrimSpace(str.Sw_KE) != "" {
		out = append(out, str.Sw_KE)
	}

	if strings.TrimSpace(str.Ta_IN) != "" {
		out = append(out, str.Ta_IN)
	}

	if strings.TrimSpace(str.Te_IN) != "" {
		out = append(out, str.Te_IN)
	}

	if strings.TrimSpace(str.Tg_TJ) != "" {
		out = append(out, str.Tg_TJ)
	}

	if strings.TrimSpace(str.Th_TH) != "" {
		out = append(out, str.Th_TH)
	}

	if strings.TrimSpace(str.Tl_PH) != "" {
		out = append(out, str.Tl_PH)
	}

	if strings.TrimSpace(str.Tr_TR) != "" {
		out = append(out, str.Tr_TR)
	}

	if strings.TrimSpace(str.Tt_RU) != "" {
		out = append(out, str.Tt_RU)
	}

	if strings.TrimSpace(str.Uk_UA) != "" {
		out = append(out, str.Uk_UA)
	}

	if strings.TrimSpace(str.Ur_PK) != "" {
		out = append(out, str.Ur_PK)
	}

	if strings.TrimSpace(str.Uz_UZ) != "" {
		out = append(out, str.Uz_UZ)
	}

	if strings.TrimSpace(str.Vi_VN) != "" {
		out = append(out, str.Vi_VN)
	}

	if strings.TrimSpace(str.Xh_ZA) != "" {
		out = append(out, str.Xh_ZA)
	}

	if strings.TrimSpace(str.Yi_DE) != "" {
		out = append(out, str.Yi_DE)
	}

	if strings.TrimSpace(str.Zh_Hans) != "" {
		out = append(out, str.Zh_Hans)
	}

	if strings.TrimSpace(str.Zh_Hant) != "" {
		out = append(out, str.Zh_Hant)
	}

	if strings.TrimSpace(str.Zh_CN) != "" {
		out = append(out, str.Zh_CN)
	}

	if strings.TrimSpace(str.Zh_HK) != "" {
		out = append(out, str.Zh_HK)
	}

	if strings.TrimSpace(str.Zh_SG) != "" {
		out = append(out, str.Zh_SG)
	}

	if strings.TrimSpace(str.Zh_TW) != "" {
		out = append(out, str.Zh_TW)
	}

	if strings.TrimSpace(str.Zu_ZA) != "" {
		out = append(out, str.Zu_ZA)
	}

	if strings.TrimSpace(str.Lo_LA) != "" {
		out = append(out, str.Lo_LA)
	}

	if strings.TrimSpace(str.Aa_ER) != "" {
		out = append(out, str.Aa_ER)
	}

	if strings.TrimSpace(str.En_SG) != "" {
		out = append(out, str.En_SG)
	}

	return out
}
func toFP(f float32) int64 {
	return int64(float64(f) * 1000000)
}

// CalcFPV turns price concurrency code to fixed point arithmetic value
// (https://en.wikipedia.org/wiki/Fixed-point_arithmetic)
// must convert to base concurrency first
func CalcFPV(price *Price, code string) int64 {
	cur := strings.TrimSpace(strings.ToUpper(code))
	if cur != "" {

		if cur == "AFN" {
			return toFP(price.GetAFN())
		}

		if cur == "EUR" {
			return toFP(price.GetEUR())
		}

		if cur == "ALL" {
			return toFP(price.GetALL())
		}

		if cur == "DZD" {
			return toFP(price.GetDZD())
		}

		if cur == "USD" {
			return toFP(price.GetUSD())
		}

		if cur == "AOA" {
			return toFP(price.GetAOA())
		}

		if cur == "XCD" {
			return toFP(price.GetXCD())
		}

		if cur == "ARS" {
			return toFP(price.GetARS())
		}

		if cur == "AMD" {
			return toFP(price.GetAMD())
		}

		if cur == "AWG" {
			return toFP(price.GetAWG())
		}

		if cur == "AUD" {
			return toFP(price.GetAUD())
		}

		if cur == "AZN" {
			return toFP(price.GetAZN())
		}

		if cur == "BSD" {
			return toFP(price.GetBSD())
		}

		if cur == "BHD" {
			return toFP(price.GetBHD())
		}

		if cur == "BDT" {
			return toFP(price.GetBDT())
		}

		if cur == "BBD" {
			return toFP(price.GetBBD())
		}

		if cur == "BYN" {
			return toFP(price.GetBYN())
		}

		if cur == "BZD" {
			return toFP(price.GetBZD())
		}

		if cur == "XOF" {
			return toFP(price.GetXOF())
		}

		if cur == "BMD" {
			return toFP(price.GetBMD())
		}

		if cur == "INR" {
			return toFP(price.GetINR())
		}

		if cur == "BTN" {
			return toFP(price.GetBTN())
		}

		if cur == "BOB" {
			return toFP(price.GetBOB())
		}

		if cur == "BOV" {
			return toFP(price.GetBOV())
		}

		if cur == "BAM" {
			return toFP(price.GetBAM())
		}

		if cur == "BWP" {
			return toFP(price.GetBWP())
		}

		if cur == "NOK" {
			return toFP(price.GetNOK())
		}

		if cur == "BRL" {
			return toFP(price.GetBRL())
		}

		if cur == "BND" {
			return toFP(price.GetBND())
		}

		if cur == "BGN" {
			return toFP(price.GetBGN())
		}

		if cur == "BIF" {
			return toFP(price.GetBIF())
		}

		if cur == "CVE" {
			return toFP(price.GetCVE())
		}

		if cur == "KHR" {
			return toFP(price.GetKHR())
		}

		if cur == "XAF" {
			return toFP(price.GetXAF())
		}

		if cur == "CAD" {
			return toFP(price.GetCAD())
		}

		if cur == "KYD" {
			return toFP(price.GetKYD())
		}

		if cur == "CLP" {
			return toFP(price.GetCLP())
		}

		if cur == "CLF" {
			return toFP(price.GetCLF())
		}

		if cur == "CNY" {
			return toFP(price.GetCNY())
		}

		if cur == "COP" {
			return toFP(price.GetCOP())
		}

		if cur == "COU" {
			return toFP(price.GetCOU())
		}

		if cur == "KMF" {
			return toFP(price.GetKMF())
		}

		if cur == "CDF" {
			return toFP(price.GetCDF())
		}

		if cur == "NZD" {
			return toFP(price.GetNZD())
		}

		if cur == "CRC" {
			return toFP(price.GetCRC())
		}

		if cur == "HRK" {
			return toFP(price.GetHRK())
		}

		if cur == "CUP" {
			return toFP(price.GetCUP())
		}

		if cur == "CUC" {
			return toFP(price.GetCUC())
		}

		if cur == "ANG" {
			return toFP(price.GetANG())
		}

		if cur == "CZK" {
			return toFP(price.GetCZK())
		}

		if cur == "DKK" {
			return toFP(price.GetDKK())
		}

		if cur == "DJF" {
			return toFP(price.GetDJF())
		}

		if cur == "DOP" {
			return toFP(price.GetDOP())
		}

		if cur == "EGP" {
			return toFP(price.GetEGP())
		}

		if cur == "SVC" {
			return toFP(price.GetSVC())
		}

		if cur == "ERN" {
			return toFP(price.GetERN())
		}

		if cur == "SZL" {
			return toFP(price.GetSZL())
		}

		if cur == "ETB" {
			return toFP(price.GetETB())
		}

		if cur == "FKP" {
			return toFP(price.GetFKP())
		}

		if cur == "FJD" {
			return toFP(price.GetFJD())
		}

		if cur == "XPF" {
			return toFP(price.GetXPF())
		}

		if cur == "GMD" {
			return toFP(price.GetGMD())
		}

		if cur == "GEL" {
			return toFP(price.GetGEL())
		}

		if cur == "GHS" {
			return toFP(price.GetGHS())
		}

		if cur == "GIP" {
			return toFP(price.GetGIP())
		}

		if cur == "GTQ" {
			return toFP(price.GetGTQ())
		}

		if cur == "GBP" {
			return toFP(price.GetGBP())
		}

		if cur == "GNF" {
			return toFP(price.GetGNF())
		}

		if cur == "GYD" {
			return toFP(price.GetGYD())
		}

		if cur == "HTG" {
			return toFP(price.GetHTG())
		}

		if cur == "HNL" {
			return toFP(price.GetHNL())
		}

		if cur == "HKD" {
			return toFP(price.GetHKD())
		}

		if cur == "HUF" {
			return toFP(price.GetHUF())
		}

		if cur == "ISK" {
			return toFP(price.GetISK())
		}

		if cur == "IDR" {
			return toFP(price.GetIDR())
		}

		if cur == "XDR" {
			return toFP(price.GetXDR())
		}

		if cur == "IRR" {
			return toFP(price.GetIRR())
		}

		if cur == "IQD" {
			return toFP(price.GetIQD())
		}

		if cur == "ILS" {
			return toFP(price.GetILS())
		}

		if cur == "JMD" {
			return toFP(price.GetJMD())
		}

		if cur == "JPY" {
			return toFP(price.GetJPY())
		}

		if cur == "JOD" {
			return toFP(price.GetJOD())
		}

		if cur == "KZT" {
			return toFP(price.GetKZT())
		}

		if cur == "KES" {
			return toFP(price.GetKES())
		}

		if cur == "KPW" {
			return toFP(price.GetKPW())
		}

		if cur == "KRW" {
			return toFP(price.GetKRW())
		}

		if cur == "KWD" {
			return toFP(price.GetKWD())
		}

		if cur == "KGS" {
			return toFP(price.GetKGS())
		}

		if cur == "LAK" {
			return toFP(price.GetLAK())
		}

		if cur == "LBP" {
			return toFP(price.GetLBP())
		}

		if cur == "LSL" {
			return toFP(price.GetLSL())
		}

		if cur == "ZAR" {
			return toFP(price.GetZAR())
		}

		if cur == "LRD" {
			return toFP(price.GetLRD())
		}

		if cur == "LYD" {
			return toFP(price.GetLYD())
		}

		if cur == "CHF" {
			return toFP(price.GetCHF())
		}

		if cur == "MOP" {
			return toFP(price.GetMOP())
		}

		if cur == "MKD" {
			return toFP(price.GetMKD())
		}

		if cur == "MGA" {
			return toFP(price.GetMGA())
		}

		if cur == "MWK" {
			return toFP(price.GetMWK())
		}

		if cur == "MYR" {
			return toFP(price.GetMYR())
		}

		if cur == "MVR" {
			return toFP(price.GetMVR())
		}

		if cur == "MRU" {
			return toFP(price.GetMRU())
		}

		if cur == "MUR" {
			return toFP(price.GetMUR())
		}

		if cur == "XUA" {
			return toFP(price.GetXUA())
		}

		if cur == "MXN" {
			return toFP(price.GetMXN())
		}

		if cur == "MXV" {
			return toFP(price.GetMXV())
		}

		if cur == "MDL" {
			return toFP(price.GetMDL())
		}

		if cur == "MNT" {
			return toFP(price.GetMNT())
		}

		if cur == "MAD" {
			return toFP(price.GetMAD())
		}

		if cur == "MZN" {
			return toFP(price.GetMZN())
		}

		if cur == "MMK" {
			return toFP(price.GetMMK())
		}

		if cur == "NAD" {
			return toFP(price.GetNAD())
		}

		if cur == "NPR" {
			return toFP(price.GetNPR())
		}

		if cur == "NIO" {
			return toFP(price.GetNIO())
		}

		if cur == "NGN" {
			return toFP(price.GetNGN())
		}

		if cur == "OMR" {
			return toFP(price.GetOMR())
		}

		if cur == "PKR" {
			return toFP(price.GetPKR())
		}

		if cur == "PAB" {
			return toFP(price.GetPAB())
		}

		if cur == "PGK" {
			return toFP(price.GetPGK())
		}

		if cur == "PYG" {
			return toFP(price.GetPYG())
		}

		if cur == "PEN" {
			return toFP(price.GetPEN())
		}

		if cur == "PHP" {
			return toFP(price.GetPHP())
		}

		if cur == "PLN" {
			return toFP(price.GetPLN())
		}

		if cur == "QAR" {
			return toFP(price.GetQAR())
		}

		if cur == "RON" {
			return toFP(price.GetRON())
		}

		if cur == "RUB" {
			return toFP(price.GetRUB())
		}

		if cur == "RWF" {
			return toFP(price.GetRWF())
		}

		if cur == "SHP" {
			return toFP(price.GetSHP())
		}

		if cur == "WST" {
			return toFP(price.GetWST())
		}

		if cur == "STN" {
			return toFP(price.GetSTN())
		}

		if cur == "SAR" {
			return toFP(price.GetSAR())
		}

		if cur == "RSD" {
			return toFP(price.GetRSD())
		}

		if cur == "SCR" {
			return toFP(price.GetSCR())
		}

		if cur == "SLL" {
			return toFP(price.GetSLL())
		}

		if cur == "SGD" {
			return toFP(price.GetSGD())
		}

		if cur == "XSU" {
			return toFP(price.GetXSU())
		}

		if cur == "SBD" {
			return toFP(price.GetSBD())
		}

		if cur == "SOS" {
			return toFP(price.GetSOS())
		}

		if cur == "SSP" {
			return toFP(price.GetSSP())
		}

		if cur == "LKR" {
			return toFP(price.GetLKR())
		}

		if cur == "SDG" {
			return toFP(price.GetSDG())
		}

		if cur == "SRD" {
			return toFP(price.GetSRD())
		}

		if cur == "SEK" {
			return toFP(price.GetSEK())
		}

		if cur == "CHE" {
			return toFP(price.GetCHE())
		}

		if cur == "CHW" {
			return toFP(price.GetCHW())
		}

		if cur == "SYP" {
			return toFP(price.GetSYP())
		}

		if cur == "TWD" {
			return toFP(price.GetTWD())
		}

		if cur == "TJS" {
			return toFP(price.GetTJS())
		}

		if cur == "TZS" {
			return toFP(price.GetTZS())
		}

		if cur == "THB" {
			return toFP(price.GetTHB())
		}

		if cur == "TOP" {
			return toFP(price.GetTOP())
		}

		if cur == "TTD" {
			return toFP(price.GetTTD())
		}

		if cur == "TND" {
			return toFP(price.GetTND())
		}

		if cur == "TRY" {
			return toFP(price.GetTRY())
		}

		if cur == "TMT" {
			return toFP(price.GetTMT())
		}

		if cur == "UGX" {
			return toFP(price.GetUGX())
		}

		if cur == "UAH" {
			return toFP(price.GetUAH())
		}

		if cur == "AED" {
			return toFP(price.GetAED())
		}

		if cur == "USN" {
			return toFP(price.GetUSN())
		}

		if cur == "UYU" {
			return toFP(price.GetUYU())
		}

		if cur == "UYI" {
			return toFP(price.GetUYI())
		}

		if cur == "UYW" {
			return toFP(price.GetUYW())
		}

		if cur == "UZS" {
			return toFP(price.GetUZS())
		}

		if cur == "VUV" {
			return toFP(price.GetVUV())
		}

		if cur == "VES" {
			return toFP(price.GetVES())
		}

		if cur == "VED" {
			return toFP(price.GetVED())
		}

		if cur == "VND" {
			return toFP(price.GetVND())
		}

		if cur == "YER" {
			return toFP(price.GetYER())
		}

		if cur == "ZMW" {
			return toFP(price.GetZMW())
		}

		if cur == "ZWL" {
			return toFP(price.GetZWL())
		}

		if cur == "XBA" {
			return toFP(price.GetXBA())
		}

		if cur == "XBB" {
			return toFP(price.GetXBB())
		}

		if cur == "XBC" {
			return toFP(price.GetXBC())
		}

		if cur == "XBD" {
			return toFP(price.GetXBD())
		}

		if cur == "XTS" {
			return toFP(price.GetXTS())
		}

		if cur == "XXX" {
			return toFP(price.GetXXX())
		}

		if cur == "XAU" {
			return toFP(price.GetXAU())
		}

		if cur == "XPD" {
			return toFP(price.GetXPD())
		}

		if cur == "XPT" {
			return toFP(price.GetXPT())
		}

		if cur == "XAG" {
			return toFP(price.GetXAG())
		}	}

	// unknow currency codd => fallback to the first non-zero

	if price.GetAFN() != 0 {
		return toFP(price.GetAFN())
	}

	if price.GetEUR() != 0 {
		return toFP(price.GetEUR())
	}

	if price.GetALL() != 0 {
		return toFP(price.GetALL())
	}

	if price.GetDZD() != 0 {
		return toFP(price.GetDZD())
	}

	if price.GetUSD() != 0 {
		return toFP(price.GetUSD())
	}

	if price.GetAOA() != 0 {
		return toFP(price.GetAOA())
	}

	if price.GetXCD() != 0 {
		return toFP(price.GetXCD())
	}

	if price.GetARS() != 0 {
		return toFP(price.GetARS())
	}

	if price.GetAMD() != 0 {
		return toFP(price.GetAMD())
	}

	if price.GetAWG() != 0 {
		return toFP(price.GetAWG())
	}

	if price.GetAUD() != 0 {
		return toFP(price.GetAUD())
	}

	if price.GetAZN() != 0 {
		return toFP(price.GetAZN())
	}

	if price.GetBSD() != 0 {
		return toFP(price.GetBSD())
	}

	if price.GetBHD() != 0 {
		return toFP(price.GetBHD())
	}

	if price.GetBDT() != 0 {
		return toFP(price.GetBDT())
	}

	if price.GetBBD() != 0 {
		return toFP(price.GetBBD())
	}

	if price.GetBYN() != 0 {
		return toFP(price.GetBYN())
	}

	if price.GetBZD() != 0 {
		return toFP(price.GetBZD())
	}

	if price.GetXOF() != 0 {
		return toFP(price.GetXOF())
	}

	if price.GetBMD() != 0 {
		return toFP(price.GetBMD())
	}

	if price.GetINR() != 0 {
		return toFP(price.GetINR())
	}

	if price.GetBTN() != 0 {
		return toFP(price.GetBTN())
	}

	if price.GetBOB() != 0 {
		return toFP(price.GetBOB())
	}

	if price.GetBOV() != 0 {
		return toFP(price.GetBOV())
	}

	if price.GetBAM() != 0 {
		return toFP(price.GetBAM())
	}

	if price.GetBWP() != 0 {
		return toFP(price.GetBWP())
	}

	if price.GetNOK() != 0 {
		return toFP(price.GetNOK())
	}

	if price.GetBRL() != 0 {
		return toFP(price.GetBRL())
	}

	if price.GetBND() != 0 {
		return toFP(price.GetBND())
	}

	if price.GetBGN() != 0 {
		return toFP(price.GetBGN())
	}

	if price.GetBIF() != 0 {
		return toFP(price.GetBIF())
	}

	if price.GetCVE() != 0 {
		return toFP(price.GetCVE())
	}

	if price.GetKHR() != 0 {
		return toFP(price.GetKHR())
	}

	if price.GetXAF() != 0 {
		return toFP(price.GetXAF())
	}

	if price.GetCAD() != 0 {
		return toFP(price.GetCAD())
	}

	if price.GetKYD() != 0 {
		return toFP(price.GetKYD())
	}

	if price.GetCLP() != 0 {
		return toFP(price.GetCLP())
	}

	if price.GetCLF() != 0 {
		return toFP(price.GetCLF())
	}

	if price.GetCNY() != 0 {
		return toFP(price.GetCNY())
	}

	if price.GetCOP() != 0 {
		return toFP(price.GetCOP())
	}

	if price.GetCOU() != 0 {
		return toFP(price.GetCOU())
	}

	if price.GetKMF() != 0 {
		return toFP(price.GetKMF())
	}

	if price.GetCDF() != 0 {
		return toFP(price.GetCDF())
	}

	if price.GetNZD() != 0 {
		return toFP(price.GetNZD())
	}

	if price.GetCRC() != 0 {
		return toFP(price.GetCRC())
	}

	if price.GetHRK() != 0 {
		return toFP(price.GetHRK())
	}

	if price.GetCUP() != 0 {
		return toFP(price.GetCUP())
	}

	if price.GetCUC() != 0 {
		return toFP(price.GetCUC())
	}

	if price.GetANG() != 0 {
		return toFP(price.GetANG())
	}

	if price.GetCZK() != 0 {
		return toFP(price.GetCZK())
	}

	if price.GetDKK() != 0 {
		return toFP(price.GetDKK())
	}

	if price.GetDJF() != 0 {
		return toFP(price.GetDJF())
	}

	if price.GetDOP() != 0 {
		return toFP(price.GetDOP())
	}

	if price.GetEGP() != 0 {
		return toFP(price.GetEGP())
	}

	if price.GetSVC() != 0 {
		return toFP(price.GetSVC())
	}

	if price.GetERN() != 0 {
		return toFP(price.GetERN())
	}

	if price.GetSZL() != 0 {
		return toFP(price.GetSZL())
	}

	if price.GetETB() != 0 {
		return toFP(price.GetETB())
	}

	if price.GetFKP() != 0 {
		return toFP(price.GetFKP())
	}

	if price.GetFJD() != 0 {
		return toFP(price.GetFJD())
	}

	if price.GetXPF() != 0 {
		return toFP(price.GetXPF())
	}

	if price.GetGMD() != 0 {
		return toFP(price.GetGMD())
	}

	if price.GetGEL() != 0 {
		return toFP(price.GetGEL())
	}

	if price.GetGHS() != 0 {
		return toFP(price.GetGHS())
	}

	if price.GetGIP() != 0 {
		return toFP(price.GetGIP())
	}

	if price.GetGTQ() != 0 {
		return toFP(price.GetGTQ())
	}

	if price.GetGBP() != 0 {
		return toFP(price.GetGBP())
	}

	if price.GetGNF() != 0 {
		return toFP(price.GetGNF())
	}

	if price.GetGYD() != 0 {
		return toFP(price.GetGYD())
	}

	if price.GetHTG() != 0 {
		return toFP(price.GetHTG())
	}

	if price.GetHNL() != 0 {
		return toFP(price.GetHNL())
	}

	if price.GetHKD() != 0 {
		return toFP(price.GetHKD())
	}

	if price.GetHUF() != 0 {
		return toFP(price.GetHUF())
	}

	if price.GetISK() != 0 {
		return toFP(price.GetISK())
	}

	if price.GetIDR() != 0 {
		return toFP(price.GetIDR())
	}

	if price.GetXDR() != 0 {
		return toFP(price.GetXDR())
	}

	if price.GetIRR() != 0 {
		return toFP(price.GetIRR())
	}

	if price.GetIQD() != 0 {
		return toFP(price.GetIQD())
	}

	if price.GetILS() != 0 {
		return toFP(price.GetILS())
	}

	if price.GetJMD() != 0 {
		return toFP(price.GetJMD())
	}

	if price.GetJPY() != 0 {
		return toFP(price.GetJPY())
	}

	if price.GetJOD() != 0 {
		return toFP(price.GetJOD())
	}

	if price.GetKZT() != 0 {
		return toFP(price.GetKZT())
	}

	if price.GetKES() != 0 {
		return toFP(price.GetKES())
	}

	if price.GetKPW() != 0 {
		return toFP(price.GetKPW())
	}

	if price.GetKRW() != 0 {
		return toFP(price.GetKRW())
	}

	if price.GetKWD() != 0 {
		return toFP(price.GetKWD())
	}

	if price.GetKGS() != 0 {
		return toFP(price.GetKGS())
	}

	if price.GetLAK() != 0 {
		return toFP(price.GetLAK())
	}

	if price.GetLBP() != 0 {
		return toFP(price.GetLBP())
	}

	if price.GetLSL() != 0 {
		return toFP(price.GetLSL())
	}

	if price.GetZAR() != 0 {
		return toFP(price.GetZAR())
	}

	if price.GetLRD() != 0 {
		return toFP(price.GetLRD())
	}

	if price.GetLYD() != 0 {
		return toFP(price.GetLYD())
	}

	if price.GetCHF() != 0 {
		return toFP(price.GetCHF())
	}

	if price.GetMOP() != 0 {
		return toFP(price.GetMOP())
	}

	if price.GetMKD() != 0 {
		return toFP(price.GetMKD())
	}

	if price.GetMGA() != 0 {
		return toFP(price.GetMGA())
	}

	if price.GetMWK() != 0 {
		return toFP(price.GetMWK())
	}

	if price.GetMYR() != 0 {
		return toFP(price.GetMYR())
	}

	if price.GetMVR() != 0 {
		return toFP(price.GetMVR())
	}

	if price.GetMRU() != 0 {
		return toFP(price.GetMRU())
	}

	if price.GetMUR() != 0 {
		return toFP(price.GetMUR())
	}

	if price.GetXUA() != 0 {
		return toFP(price.GetXUA())
	}

	if price.GetMXN() != 0 {
		return toFP(price.GetMXN())
	}

	if price.GetMXV() != 0 {
		return toFP(price.GetMXV())
	}

	if price.GetMDL() != 0 {
		return toFP(price.GetMDL())
	}

	if price.GetMNT() != 0 {
		return toFP(price.GetMNT())
	}

	if price.GetMAD() != 0 {
		return toFP(price.GetMAD())
	}

	if price.GetMZN() != 0 {
		return toFP(price.GetMZN())
	}

	if price.GetMMK() != 0 {
		return toFP(price.GetMMK())
	}

	if price.GetNAD() != 0 {
		return toFP(price.GetNAD())
	}

	if price.GetNPR() != 0 {
		return toFP(price.GetNPR())
	}

	if price.GetNIO() != 0 {
		return toFP(price.GetNIO())
	}

	if price.GetNGN() != 0 {
		return toFP(price.GetNGN())
	}

	if price.GetOMR() != 0 {
		return toFP(price.GetOMR())
	}

	if price.GetPKR() != 0 {
		return toFP(price.GetPKR())
	}

	if price.GetPAB() != 0 {
		return toFP(price.GetPAB())
	}

	if price.GetPGK() != 0 {
		return toFP(price.GetPGK())
	}

	if price.GetPYG() != 0 {
		return toFP(price.GetPYG())
	}

	if price.GetPEN() != 0 {
		return toFP(price.GetPEN())
	}

	if price.GetPHP() != 0 {
		return toFP(price.GetPHP())
	}

	if price.GetPLN() != 0 {
		return toFP(price.GetPLN())
	}

	if price.GetQAR() != 0 {
		return toFP(price.GetQAR())
	}

	if price.GetRON() != 0 {
		return toFP(price.GetRON())
	}

	if price.GetRUB() != 0 {
		return toFP(price.GetRUB())
	}

	if price.GetRWF() != 0 {
		return toFP(price.GetRWF())
	}

	if price.GetSHP() != 0 {
		return toFP(price.GetSHP())
	}

	if price.GetWST() != 0 {
		return toFP(price.GetWST())
	}

	if price.GetSTN() != 0 {
		return toFP(price.GetSTN())
	}

	if price.GetSAR() != 0 {
		return toFP(price.GetSAR())
	}

	if price.GetRSD() != 0 {
		return toFP(price.GetRSD())
	}

	if price.GetSCR() != 0 {
		return toFP(price.GetSCR())
	}

	if price.GetSLL() != 0 {
		return toFP(price.GetSLL())
	}

	if price.GetSGD() != 0 {
		return toFP(price.GetSGD())
	}

	if price.GetXSU() != 0 {
		return toFP(price.GetXSU())
	}

	if price.GetSBD() != 0 {
		return toFP(price.GetSBD())
	}

	if price.GetSOS() != 0 {
		return toFP(price.GetSOS())
	}

	if price.GetSSP() != 0 {
		return toFP(price.GetSSP())
	}

	if price.GetLKR() != 0 {
		return toFP(price.GetLKR())
	}

	if price.GetSDG() != 0 {
		return toFP(price.GetSDG())
	}

	if price.GetSRD() != 0 {
		return toFP(price.GetSRD())
	}

	if price.GetSEK() != 0 {
		return toFP(price.GetSEK())
	}

	if price.GetCHE() != 0 {
		return toFP(price.GetCHE())
	}

	if price.GetCHW() != 0 {
		return toFP(price.GetCHW())
	}

	if price.GetSYP() != 0 {
		return toFP(price.GetSYP())
	}

	if price.GetTWD() != 0 {
		return toFP(price.GetTWD())
	}

	if price.GetTJS() != 0 {
		return toFP(price.GetTJS())
	}

	if price.GetTZS() != 0 {
		return toFP(price.GetTZS())
	}

	if price.GetTHB() != 0 {
		return toFP(price.GetTHB())
	}

	if price.GetTOP() != 0 {
		return toFP(price.GetTOP())
	}

	if price.GetTTD() != 0 {
		return toFP(price.GetTTD())
	}

	if price.GetTND() != 0 {
		return toFP(price.GetTND())
	}

	if price.GetTRY() != 0 {
		return toFP(price.GetTRY())
	}

	if price.GetTMT() != 0 {
		return toFP(price.GetTMT())
	}

	if price.GetUGX() != 0 {
		return toFP(price.GetUGX())
	}

	if price.GetUAH() != 0 {
		return toFP(price.GetUAH())
	}

	if price.GetAED() != 0 {
		return toFP(price.GetAED())
	}

	if price.GetUSN() != 0 {
		return toFP(price.GetUSN())
	}

	if price.GetUYU() != 0 {
		return toFP(price.GetUYU())
	}

	if price.GetUYI() != 0 {
		return toFP(price.GetUYI())
	}

	if price.GetUYW() != 0 {
		return toFP(price.GetUYW())
	}

	if price.GetUZS() != 0 {
		return toFP(price.GetUZS())
	}

	if price.GetVUV() != 0 {
		return toFP(price.GetVUV())
	}

	if price.GetVES() != 0 {
		return toFP(price.GetVES())
	}

	if price.GetVED() != 0 {
		return toFP(price.GetVED())
	}

	if price.GetVND() != 0 {
		return toFP(price.GetVND())
	}

	if price.GetYER() != 0 {
		return toFP(price.GetYER())
	}

	if price.GetZMW() != 0 {
		return toFP(price.GetZMW())
	}

	if price.GetZWL() != 0 {
		return toFP(price.GetZWL())
	}

	if price.GetXBA() != 0 {
		return toFP(price.GetXBA())
	}

	if price.GetXBB() != 0 {
		return toFP(price.GetXBB())
	}

	if price.GetXBC() != 0 {
		return toFP(price.GetXBC())
	}

	if price.GetXBD() != 0 {
		return toFP(price.GetXBD())
	}

	if price.GetXTS() != 0 {
		return toFP(price.GetXTS())
	}

	if price.GetXXX() != 0 {
		return toFP(price.GetXXX())
	}

	if price.GetXAU() != 0 {
		return toFP(price.GetXAU())
	}

	if price.GetXPD() != 0 {
		return toFP(price.GetXPD())
	}

	if price.GetXPT() != 0 {
		return toFP(price.GetXPT())
	}

	if price.GetXAG() != 0 {
		return toFP(price.GetXAG())
	}
	return 0
}

func SetCurrency(price *Price, code string, value float32) {
	cur := strings.TrimSpace(strings.ToUpper(code))
	if cur != "" {
		return
	}

	if cur == "AFN" {
		price.AFN = value
	}

	if cur == "EUR" {
		price.EUR = value
	}

	if cur == "ALL" {
		price.ALL = value
	}

	if cur == "DZD" {
		price.DZD = value
	}

	if cur == "USD" {
		price.USD = value
	}

	if cur == "AOA" {
		price.AOA = value
	}

	if cur == "XCD" {
		price.XCD = value
	}

	if cur == "ARS" {
		price.ARS = value
	}

	if cur == "AMD" {
		price.AMD = value
	}

	if cur == "AWG" {
		price.AWG = value
	}

	if cur == "AUD" {
		price.AUD = value
	}

	if cur == "AZN" {
		price.AZN = value
	}

	if cur == "BSD" {
		price.BSD = value
	}

	if cur == "BHD" {
		price.BHD = value
	}

	if cur == "BDT" {
		price.BDT = value
	}

	if cur == "BBD" {
		price.BBD = value
	}

	if cur == "BYN" {
		price.BYN = value
	}

	if cur == "BZD" {
		price.BZD = value
	}

	if cur == "XOF" {
		price.XOF = value
	}

	if cur == "BMD" {
		price.BMD = value
	}

	if cur == "INR" {
		price.INR = value
	}

	if cur == "BTN" {
		price.BTN = value
	}

	if cur == "BOB" {
		price.BOB = value
	}

	if cur == "BOV" {
		price.BOV = value
	}

	if cur == "BAM" {
		price.BAM = value
	}

	if cur == "BWP" {
		price.BWP = value
	}

	if cur == "NOK" {
		price.NOK = value
	}

	if cur == "BRL" {
		price.BRL = value
	}

	if cur == "BND" {
		price.BND = value
	}

	if cur == "BGN" {
		price.BGN = value
	}

	if cur == "BIF" {
		price.BIF = value
	}

	if cur == "CVE" {
		price.CVE = value
	}

	if cur == "KHR" {
		price.KHR = value
	}

	if cur == "XAF" {
		price.XAF = value
	}

	if cur == "CAD" {
		price.CAD = value
	}

	if cur == "KYD" {
		price.KYD = value
	}

	if cur == "CLP" {
		price.CLP = value
	}

	if cur == "CLF" {
		price.CLF = value
	}

	if cur == "CNY" {
		price.CNY = value
	}

	if cur == "COP" {
		price.COP = value
	}

	if cur == "COU" {
		price.COU = value
	}

	if cur == "KMF" {
		price.KMF = value
	}

	if cur == "CDF" {
		price.CDF = value
	}

	if cur == "NZD" {
		price.NZD = value
	}

	if cur == "CRC" {
		price.CRC = value
	}

	if cur == "HRK" {
		price.HRK = value
	}

	if cur == "CUP" {
		price.CUP = value
	}

	if cur == "CUC" {
		price.CUC = value
	}

	if cur == "ANG" {
		price.ANG = value
	}

	if cur == "CZK" {
		price.CZK = value
	}

	if cur == "DKK" {
		price.DKK = value
	}

	if cur == "DJF" {
		price.DJF = value
	}

	if cur == "DOP" {
		price.DOP = value
	}

	if cur == "EGP" {
		price.EGP = value
	}

	if cur == "SVC" {
		price.SVC = value
	}

	if cur == "ERN" {
		price.ERN = value
	}

	if cur == "SZL" {
		price.SZL = value
	}

	if cur == "ETB" {
		price.ETB = value
	}

	if cur == "FKP" {
		price.FKP = value
	}

	if cur == "FJD" {
		price.FJD = value
	}

	if cur == "XPF" {
		price.XPF = value
	}

	if cur == "GMD" {
		price.GMD = value
	}

	if cur == "GEL" {
		price.GEL = value
	}

	if cur == "GHS" {
		price.GHS = value
	}

	if cur == "GIP" {
		price.GIP = value
	}

	if cur == "GTQ" {
		price.GTQ = value
	}

	if cur == "GBP" {
		price.GBP = value
	}

	if cur == "GNF" {
		price.GNF = value
	}

	if cur == "GYD" {
		price.GYD = value
	}

	if cur == "HTG" {
		price.HTG = value
	}

	if cur == "HNL" {
		price.HNL = value
	}

	if cur == "HKD" {
		price.HKD = value
	}

	if cur == "HUF" {
		price.HUF = value
	}

	if cur == "ISK" {
		price.ISK = value
	}

	if cur == "IDR" {
		price.IDR = value
	}

	if cur == "XDR" {
		price.XDR = value
	}

	if cur == "IRR" {
		price.IRR = value
	}

	if cur == "IQD" {
		price.IQD = value
	}

	if cur == "ILS" {
		price.ILS = value
	}

	if cur == "JMD" {
		price.JMD = value
	}

	if cur == "JPY" {
		price.JPY = value
	}

	if cur == "JOD" {
		price.JOD = value
	}

	if cur == "KZT" {
		price.KZT = value
	}

	if cur == "KES" {
		price.KES = value
	}

	if cur == "KPW" {
		price.KPW = value
	}

	if cur == "KRW" {
		price.KRW = value
	}

	if cur == "KWD" {
		price.KWD = value
	}

	if cur == "KGS" {
		price.KGS = value
	}

	if cur == "LAK" {
		price.LAK = value
	}

	if cur == "LBP" {
		price.LBP = value
	}

	if cur == "LSL" {
		price.LSL = value
	}

	if cur == "ZAR" {
		price.ZAR = value
	}

	if cur == "LRD" {
		price.LRD = value
	}

	if cur == "LYD" {
		price.LYD = value
	}

	if cur == "CHF" {
		price.CHF = value
	}

	if cur == "MOP" {
		price.MOP = value
	}

	if cur == "MKD" {
		price.MKD = value
	}

	if cur == "MGA" {
		price.MGA = value
	}

	if cur == "MWK" {
		price.MWK = value
	}

	if cur == "MYR" {
		price.MYR = value
	}

	if cur == "MVR" {
		price.MVR = value
	}

	if cur == "MRU" {
		price.MRU = value
	}

	if cur == "MUR" {
		price.MUR = value
	}

	if cur == "XUA" {
		price.XUA = value
	}

	if cur == "MXN" {
		price.MXN = value
	}

	if cur == "MXV" {
		price.MXV = value
	}

	if cur == "MDL" {
		price.MDL = value
	}

	if cur == "MNT" {
		price.MNT = value
	}

	if cur == "MAD" {
		price.MAD = value
	}

	if cur == "MZN" {
		price.MZN = value
	}

	if cur == "MMK" {
		price.MMK = value
	}

	if cur == "NAD" {
		price.NAD = value
	}

	if cur == "NPR" {
		price.NPR = value
	}

	if cur == "NIO" {
		price.NIO = value
	}

	if cur == "NGN" {
		price.NGN = value
	}

	if cur == "OMR" {
		price.OMR = value
	}

	if cur == "PKR" {
		price.PKR = value
	}

	if cur == "PAB" {
		price.PAB = value
	}

	if cur == "PGK" {
		price.PGK = value
	}

	if cur == "PYG" {
		price.PYG = value
	}

	if cur == "PEN" {
		price.PEN = value
	}

	if cur == "PHP" {
		price.PHP = value
	}

	if cur == "PLN" {
		price.PLN = value
	}

	if cur == "QAR" {
		price.QAR = value
	}

	if cur == "RON" {
		price.RON = value
	}

	if cur == "RUB" {
		price.RUB = value
	}

	if cur == "RWF" {
		price.RWF = value
	}

	if cur == "SHP" {
		price.SHP = value
	}

	if cur == "WST" {
		price.WST = value
	}

	if cur == "STN" {
		price.STN = value
	}

	if cur == "SAR" {
		price.SAR = value
	}

	if cur == "RSD" {
		price.RSD = value
	}

	if cur == "SCR" {
		price.SCR = value
	}

	if cur == "SLL" {
		price.SLL = value
	}

	if cur == "SGD" {
		price.SGD = value
	}

	if cur == "XSU" {
		price.XSU = value
	}

	if cur == "SBD" {
		price.SBD = value
	}

	if cur == "SOS" {
		price.SOS = value
	}

	if cur == "SSP" {
		price.SSP = value
	}

	if cur == "LKR" {
		price.LKR = value
	}

	if cur == "SDG" {
		price.SDG = value
	}

	if cur == "SRD" {
		price.SRD = value
	}

	if cur == "SEK" {
		price.SEK = value
	}

	if cur == "CHE" {
		price.CHE = value
	}

	if cur == "CHW" {
		price.CHW = value
	}

	if cur == "SYP" {
		price.SYP = value
	}

	if cur == "TWD" {
		price.TWD = value
	}

	if cur == "TJS" {
		price.TJS = value
	}

	if cur == "TZS" {
		price.TZS = value
	}

	if cur == "THB" {
		price.THB = value
	}

	if cur == "TOP" {
		price.TOP = value
	}

	if cur == "TTD" {
		price.TTD = value
	}

	if cur == "TND" {
		price.TND = value
	}

	if cur == "TRY" {
		price.TRY = value
	}

	if cur == "TMT" {
		price.TMT = value
	}

	if cur == "UGX" {
		price.UGX = value
	}

	if cur == "UAH" {
		price.UAH = value
	}

	if cur == "AED" {
		price.AED = value
	}

	if cur == "USN" {
		price.USN = value
	}

	if cur == "UYU" {
		price.UYU = value
	}

	if cur == "UYI" {
		price.UYI = value
	}

	if cur == "UYW" {
		price.UYW = value
	}

	if cur == "UZS" {
		price.UZS = value
	}

	if cur == "VUV" {
		price.VUV = value
	}

	if cur == "VES" {
		price.VES = value
	}

	if cur == "VED" {
		price.VED = value
	}

	if cur == "VND" {
		price.VND = value
	}

	if cur == "YER" {
		price.YER = value
	}

	if cur == "ZMW" {
		price.ZMW = value
	}

	if cur == "ZWL" {
		price.ZWL = value
	}

	if cur == "XBA" {
		price.XBA = value
	}

	if cur == "XBB" {
		price.XBB = value
	}

	if cur == "XBC" {
		price.XBC = value
	}

	if cur == "XBD" {
		price.XBD = value
	}

	if cur == "XTS" {
		price.XTS = value
	}

	if cur == "XXX" {
		price.XXX = value
	}

	if cur == "XAU" {
		price.XAU = value
	}

	if cur == "XPD" {
		price.XPD = value
	}

	if cur == "XPT" {
		price.XPT = value
	}

	if cur == "XAG" {
		price.XAG = value
	}
}