# File lib/cidr.rb, line 110
    def CIDR.create(addr, options=nil)
        known_args = [:Mask, :Version, :Tag, :WildcardMask]
        ip, netmask, tag = nil, nil, {}
        version, wildcard_mask ,wildcard_mask_bit_flipped = nil, nil, false
        netmask_int, all_f = nil, nil

        # validate options
        if (options)
            raise ArgumentError, "Hash expected for argument 'options' but " +
                                 "#{options.class} provided." if (!options.kind_of?(Hash) )
            NetAddr.validate_args(options.keys,known_args)

            if (options.has_key?(:Mask))
                netmask_int = options[:Mask]
                raise ArgumentError, "Expected Integer, but #{netmask_int.class} " +
                                     "provided for option :Mask." if (!netmask_int.kind_of?(Integer))
            end

            if (options.has_key?(:Tag))
                tag = options[:Tag]
                if (!tag.kind_of? Hash)
                    raise ArgumentError, "Expected Hash, but #{tag.class} provided for option :Tag."
                end
            end

            if (options.has_key?(:Version))
                version = options[:Version]
                if (version != 4 && version != 6)
                    raise VersionError, ":Version should be 4 or 6, but was '#{version}'."
                end
            end

            if (options.has_key?(:WildcardMask))
                if (!options[:WildcardMask].kind_of?(Array))
                    raise ArgumentError, "Expected Array, but #{options[:WildcardMask].class} provided for option :WildcardMask."
                end

                wildcard_mask = options[:WildcardMask][0]
                if (!wildcard_mask.kind_of?(String) &&  !wildcard_mask.kind_of?(Integer))
                    raise ArgumentError, "Expected String or Integer, but #{wildcard_mask.class} provided for wildcard mask."
                end
                wildcard_mask_bit_flipped = true if (options[:WildcardMask][1] && options[:WildcardMask][1].kind_of?(TrueClass))
            end
        end

        # validate addr arg & set version if not provided by user
        if (addr.kind_of?(String))
            version = NetAddr.detect_ip_version(addr) if (!version)

            # if extended netmask provided. should only apply to ipv4
            if (version == 4 && addr =~ /.+\s+.+/ )
                addr,netmask = addr.split(' ')
            end

            # if netmask part of ip, then separate ip & mask.
            if (addr =~ /\//)
                ip,netmask = addr.split(/\//)
                if (!ip || !netmask)
                    raise ArgumentError, "CIDR address is improperly formatted. Missing netmask after '/' character." 
                end
            else
                ip = addr
            end

            NetAddr.validate_ip_str(ip,version)
            ip = NetAddr.ip_str_to_int(ip,version)

        elsif (addr.kind_of?(Integer))
            ip = addr
            if (!version)
                if (ip < 2**32)
                    version = 4
                else
                    version = 6
                end
            end
            NetAddr.validate_ip_int(ip,version)

        else
            raise ArgumentError, "String or Integer expected for argument 'addr' but #{addr.class} provided."
        end

        # set all_f based on version
        all_f = 2**32-1
        all_f = 2**128-1 if (version == 6)

        # set netmask. netmask_int takes precedence. set to all_f if no netmask provided
        if (netmask_int)
            NetAddr.validate_netmask_int(netmask_int,version,true)
            netmask = netmask_int
        elsif (netmask)
            NetAddr.validate_netmask_str(netmask,version)
            netmask = NetAddr.netmask_str_to_int(netmask, version)
        else
            netmask = all_f
        end

        # set wildcard mask if not provided, or validate if provided.
        if (wildcard_mask)
            begin
                if (wildcard_mask.kind_of?(String))
                    NetAddr.validate_ip_str(wildcard_mask,version)
                    wildcard_mask = NetAddr.ip_str_to_int(wildcard_mask, version)
                else (wildcard_mask.kind_of?(Integer))
                    NetAddr.validate_ip_int(wildcard_mask,version)
                end
            rescue Exception => error
                raise ValidationError, "Provided wildcard mask failed validation: #{error}"
            end
        end

        return( NetAddr.cidr_build(version, ip, netmask, tag, wildcard_mask, wildcard_mask_bit_flipped) )
    end