package envconf

import "time"

type mapEnvType [5]*keyLookupType

func (c *Config) GetMapInt(key string) (empty map[string]int64) {
	empty = make(map[string]int64)
	retval := make(map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[0].next[key]
		if ok {
			for k11, v11 := range v10.next {
				entry := c.env[v11.key]
				if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
					retval[k11] = entry.parsed.intval
				} else {
					return
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMetric(key string) (empty map[string]int64) {
	empty = make(map[string]int64)
	retval := make(map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[0].next[key]
		if ok {
			for k11, v11 := range v10.next {
				entry := c.env[v11.key]
				if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
					retval[k11] = entry.parsed.intval
				} else {
					return
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapDuration(key string) (empty map[string]time.Duration) {
	empty = make(map[string]time.Duration)
	retval := make(map[string]time.Duration)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[0].next[key]
		if ok {
			for k11, v11 := range v10.next {
				entry := c.env[v11.key]
				if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
					retval[k11] = entry.parsed.durval
				} else {
					return
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapString(key string) (empty map[string]string) {
	empty = make(map[string]string)
	retval := make(map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[0].next[key]
		if ok {
			for k11, v11 := range v10.next {
				entry := c.env[v11.key]
				if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
					retval[k11] = entry.parsed.strval
				} else {
					return
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapDirectory(key string) (empty map[string]string) {
	empty = make(map[string]string)
	retval := make(map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[0].next[key]
		if ok {
			for k11, v11 := range v10.next {
				entry := c.env[v11.key]
				if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
					retval[k11] = entry.parsed.strval
				} else {
					return
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapBool(key string) (empty map[string]bool) {
	empty = make(map[string]bool)
	retval := make(map[string]bool)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[0].next[key]
		if ok {
			for k11, v11 := range v10.next {
				entry := c.env[v11.key]
				if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
					retval[k11] = entry.parsed.boolval
				} else {
					return
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapHex(key string) (empty map[string][]byte) {
	empty = make(map[string][]byte)
	retval := make(map[string][]byte)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[0].next[key]
		if ok {
			for k11, v11 := range v10.next {
				entry := c.env[v11.key]
				if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
					retval[k11] = entry.parsed.binval
				} else {
					return
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapInt(key string) (empty map[string]map[string]int64) {
	empty = make(map[string]map[string]int64)
	retval := make(map[string]map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[1].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]int64)
				for k12, v12 := range v11.next {
					entry := c.env[v12.key]
					if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
						retval[k11][k12] = entry.parsed.intval
					} else {
						return
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMetric(key string) (empty map[string]map[string]int64) {
	empty = make(map[string]map[string]int64)
	retval := make(map[string]map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[1].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]int64)
				for k12, v12 := range v11.next {
					entry := c.env[v12.key]
					if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
						retval[k11][k12] = entry.parsed.intval
					} else {
						return
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapDuration(key string) (empty map[string]map[string]time.Duration) {
	empty = make(map[string]map[string]time.Duration)
	retval := make(map[string]map[string]time.Duration)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[1].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]time.Duration)
				for k12, v12 := range v11.next {
					entry := c.env[v12.key]
					if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
						retval[k11][k12] = entry.parsed.durval
					} else {
						return
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapString(key string) (empty map[string]map[string]string) {
	empty = make(map[string]map[string]string)
	retval := make(map[string]map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[1].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]string)
				for k12, v12 := range v11.next {
					entry := c.env[v12.key]
					if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
						retval[k11][k12] = entry.parsed.strval
					} else {
						return
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapDirectory(key string) (empty map[string]map[string]string) {
	empty = make(map[string]map[string]string)
	retval := make(map[string]map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[1].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]string)
				for k12, v12 := range v11.next {
					entry := c.env[v12.key]
					if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
						retval[k11][k12] = entry.parsed.strval
					} else {
						return
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapBool(key string) (empty map[string]map[string]bool) {
	empty = make(map[string]map[string]bool)
	retval := make(map[string]map[string]bool)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[1].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]bool)
				for k12, v12 := range v11.next {
					entry := c.env[v12.key]
					if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
						retval[k11][k12] = entry.parsed.boolval
					} else {
						return
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapHex(key string) (empty map[string]map[string][]byte) {
	empty = make(map[string]map[string][]byte)
	retval := make(map[string]map[string][]byte)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[1].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string][]byte)
				for k12, v12 := range v11.next {
					entry := c.env[v12.key]
					if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
						retval[k11][k12] = entry.parsed.binval
					} else {
						return
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapInt(key string) (empty map[string]map[string]map[string]int64) {
	empty = make(map[string]map[string]map[string]int64)
	retval := make(map[string]map[string]map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[2].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]int64)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]int64)
					for k13, v13 := range v12.next {
						entry := c.env[v13.key]
						if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
							retval[k11][k12][k13] = entry.parsed.intval
						} else {
							return
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMetric(key string) (empty map[string]map[string]map[string]int64) {
	empty = make(map[string]map[string]map[string]int64)
	retval := make(map[string]map[string]map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[2].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]int64)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]int64)
					for k13, v13 := range v12.next {
						entry := c.env[v13.key]
						if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
							retval[k11][k12][k13] = entry.parsed.intval
						} else {
							return
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapDuration(key string) (empty map[string]map[string]map[string]time.Duration) {
	empty = make(map[string]map[string]map[string]time.Duration)
	retval := make(map[string]map[string]map[string]time.Duration)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[2].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]time.Duration)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]time.Duration)
					for k13, v13 := range v12.next {
						entry := c.env[v13.key]
						if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
							retval[k11][k12][k13] = entry.parsed.durval
						} else {
							return
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapString(key string) (empty map[string]map[string]map[string]string) {
	empty = make(map[string]map[string]map[string]string)
	retval := make(map[string]map[string]map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[2].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]string)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]string)
					for k13, v13 := range v12.next {
						entry := c.env[v13.key]
						if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
							retval[k11][k12][k13] = entry.parsed.strval
						} else {
							return
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapDirectory(key string) (empty map[string]map[string]map[string]string) {
	empty = make(map[string]map[string]map[string]string)
	retval := make(map[string]map[string]map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[2].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]string)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]string)
					for k13, v13 := range v12.next {
						entry := c.env[v13.key]
						if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
							retval[k11][k12][k13] = entry.parsed.strval
						} else {
							return
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapBool(key string) (empty map[string]map[string]map[string]bool) {
	empty = make(map[string]map[string]map[string]bool)
	retval := make(map[string]map[string]map[string]bool)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[2].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]bool)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]bool)
					for k13, v13 := range v12.next {
						entry := c.env[v13.key]
						if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
							retval[k11][k12][k13] = entry.parsed.boolval
						} else {
							return
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapHex(key string) (empty map[string]map[string]map[string][]byte) {
	empty = make(map[string]map[string]map[string][]byte)
	retval := make(map[string]map[string]map[string][]byte)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[2].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string][]byte)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string][]byte)
					for k13, v13 := range v12.next {
						entry := c.env[v13.key]
						if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
							retval[k11][k12][k13] = entry.parsed.binval
						} else {
							return
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapInt(key string) (empty map[string]map[string]map[string]map[string]int64) {
	empty = make(map[string]map[string]map[string]map[string]int64)
	retval := make(map[string]map[string]map[string]map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[3].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]int64)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]int64)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]int64)
						for k14, v14 := range v13.next {
							entry := c.env[v14.key]
							if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
								retval[k11][k12][k13][k14] = entry.parsed.intval
							} else {
								return
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapMetric(key string) (empty map[string]map[string]map[string]map[string]int64) {
	empty = make(map[string]map[string]map[string]map[string]int64)
	retval := make(map[string]map[string]map[string]map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[3].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]int64)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]int64)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]int64)
						for k14, v14 := range v13.next {
							entry := c.env[v14.key]
							if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
								retval[k11][k12][k13][k14] = entry.parsed.intval
							} else {
								return
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapDuration(key string) (empty map[string]map[string]map[string]map[string]time.Duration) {
	empty = make(map[string]map[string]map[string]map[string]time.Duration)
	retval := make(map[string]map[string]map[string]map[string]time.Duration)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[3].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]time.Duration)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]time.Duration)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]time.Duration)
						for k14, v14 := range v13.next {
							entry := c.env[v14.key]
							if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
								retval[k11][k12][k13][k14] = entry.parsed.durval
							} else {
								return
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapString(key string) (empty map[string]map[string]map[string]map[string]string) {
	empty = make(map[string]map[string]map[string]map[string]string)
	retval := make(map[string]map[string]map[string]map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[3].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]string)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]string)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]string)
						for k14, v14 := range v13.next {
							entry := c.env[v14.key]
							if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
								retval[k11][k12][k13][k14] = entry.parsed.strval
							} else {
								return
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapDirectory(key string) (empty map[string]map[string]map[string]map[string]string) {
	empty = make(map[string]map[string]map[string]map[string]string)
	retval := make(map[string]map[string]map[string]map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[3].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]string)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]string)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]string)
						for k14, v14 := range v13.next {
							entry := c.env[v14.key]
							if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
								retval[k11][k12][k13][k14] = entry.parsed.strval
							} else {
								return
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapBool(key string) (empty map[string]map[string]map[string]map[string]bool) {
	empty = make(map[string]map[string]map[string]map[string]bool)
	retval := make(map[string]map[string]map[string]map[string]bool)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[3].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]bool)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]bool)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]bool)
						for k14, v14 := range v13.next {
							entry := c.env[v14.key]
							if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
								retval[k11][k12][k13][k14] = entry.parsed.boolval
							} else {
								return
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapHex(key string) (empty map[string]map[string]map[string]map[string][]byte) {
	empty = make(map[string]map[string]map[string]map[string][]byte)
	retval := make(map[string]map[string]map[string]map[string][]byte)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[3].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string][]byte)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string][]byte)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string][]byte)
						for k14, v14 := range v13.next {
							entry := c.env[v14.key]
							if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
								retval[k11][k12][k13][k14] = entry.parsed.binval
							} else {
								return
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapMapInt(key string) (empty map[string]map[string]map[string]map[string]map[string]int64) {
	empty = make(map[string]map[string]map[string]map[string]map[string]int64)
	retval := make(map[string]map[string]map[string]map[string]map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[4].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]map[string]int64)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]map[string]int64)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]map[string]int64)
						for k14, v14 := range v13.next {
							retval[k11][k12][k13][k14] = make(map[string]int64)
							for k15, v15 := range v14.next {
								entry := c.env[v15.key]
								if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
									retval[k11][k12][k13][k14][k15] = entry.parsed.intval
								} else {
									return
								}
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapMapMetric(key string) (empty map[string]map[string]map[string]map[string]map[string]int64) {
	empty = make(map[string]map[string]map[string]map[string]map[string]int64)
	retval := make(map[string]map[string]map[string]map[string]map[string]int64)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[4].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]map[string]int64)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]map[string]int64)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]map[string]int64)
						for k14, v14 := range v13.next {
							retval[k11][k12][k13][k14] = make(map[string]int64)
							for k15, v15 := range v14.next {
								entry := c.env[v15.key]
								if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
									retval[k11][k12][k13][k14][k15] = entry.parsed.intval
								} else {
									return
								}
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapMapDuration(key string) (empty map[string]map[string]map[string]map[string]map[string]time.Duration) {
	empty = make(map[string]map[string]map[string]map[string]map[string]time.Duration)
	retval := make(map[string]map[string]map[string]map[string]map[string]time.Duration)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[4].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]map[string]time.Duration)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]map[string]time.Duration)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]map[string]time.Duration)
						for k14, v14 := range v13.next {
							retval[k11][k12][k13][k14] = make(map[string]time.Duration)
							for k15, v15 := range v14.next {
								entry := c.env[v15.key]
								if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
									retval[k11][k12][k13][k14][k15] = entry.parsed.durval
								} else {
									return
								}
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapMapString(key string) (empty map[string]map[string]map[string]map[string]map[string]string) {
	empty = make(map[string]map[string]map[string]map[string]map[string]string)
	retval := make(map[string]map[string]map[string]map[string]map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[4].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]map[string]string)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]map[string]string)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]map[string]string)
						for k14, v14 := range v13.next {
							retval[k11][k12][k13][k14] = make(map[string]string)
							for k15, v15 := range v14.next {
								entry := c.env[v15.key]
								if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
									retval[k11][k12][k13][k14][k15] = entry.parsed.strval
								} else {
									return
								}
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapMapDirectory(key string) (empty map[string]map[string]map[string]map[string]map[string]string) {
	empty = make(map[string]map[string]map[string]map[string]map[string]string)
	retval := make(map[string]map[string]map[string]map[string]map[string]string)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[4].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]map[string]string)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]map[string]string)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]map[string]string)
						for k14, v14 := range v13.next {
							retval[k11][k12][k13][k14] = make(map[string]string)
							for k15, v15 := range v14.next {
								entry := c.env[v15.key]
								if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
									retval[k11][k12][k13][k14][k15] = entry.parsed.strval
								} else {
									return
								}
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapMapBool(key string) (empty map[string]map[string]map[string]map[string]map[string]bool) {
	empty = make(map[string]map[string]map[string]map[string]map[string]bool)
	retval := make(map[string]map[string]map[string]map[string]map[string]bool)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[4].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]map[string]bool)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]map[string]bool)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]map[string]bool)
						for k14, v14 := range v13.next {
							retval[k11][k12][k13][k14] = make(map[string]bool)
							for k15, v15 := range v14.next {
								entry := c.env[v15.key]
								if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
									retval[k11][k12][k13][k14][k15] = entry.parsed.boolval
								} else {
									return
								}
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}
func (c *Config) GetMapMapMapMapMapHex(key string) (empty map[string]map[string]map[string]map[string]map[string][]byte) {
	empty = make(map[string]map[string]map[string]map[string]map[string][]byte)
	retval := make(map[string]map[string]map[string]map[string]map[string][]byte)
	if c.parsed {
		key = cleanKey(key)
		v10, ok := c.mapEnv[4].next[key]
		if ok {
			for k11, v11 := range v10.next {
				retval[k11] = make(map[string]map[string]map[string]map[string][]byte)
				for k12, v12 := range v11.next {
					retval[k11][k12] = make(map[string]map[string]map[string][]byte)
					for k13, v13 := range v12.next {
						retval[k11][k12][k13] = make(map[string]map[string][]byte)
						for k14, v14 := range v13.next {
							retval[k11][k12][k13][k14] = make(map[string][]byte)
							for k15, v15 := range v14.next {
								entry := c.env[v15.key]
								if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
									retval[k11][k12][k13][k14][k15] = entry.parsed.binval
								} else {
									return
								}
							}
						}
					}
				}
			}
			return retval
		}
	}
	return
}