<?php

namespace Medoo\Tests;

use Medoo\Medoo;

/**
 * @coversDefaultClass \Medoo\Medoo
 */
class WhereTest extends MedooTestCase
{
    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::typeMap()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testBasicWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "email" => "foo@bar.com",
            "user_id" => 200,
            "user_id[>]" => 200,
            "user_id[>=]" => 200,
            "user_id[!]" => 200,
            "age[<>]" => [200, 500],
            "age[><]" => [200, 500],
            "income[>]" => Medoo::raw("COUNT(<average>)"),
            "remote_id" => Medoo::raw("UUID()"),
            "location" => null,
            "is_selected" => true
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n"email" = 'foo@bar.com' AND\n"user_id" = 200 AND\n"user_id" > 200 AND\n"user_id" >= 200 AND\n"user_id" != 200 AND\n("age" BETWEEN 200 AND 500) AND\n("age" NOT BETWEEN 200 AND 500) AND\n"income" > COUNT("average") AND\n"remote_id" = UUID() AND\n"location" IS NULL AND\n"is_selected" = 1",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testBetweenDateTimeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "birthday[<>]" => [date("Y-m-d", mktime(0, 0, 0, 1, 1, 2015)), date("Y-m-d", mktime(0, 0, 0, 1, 1, 2045))]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("birthday" BETWEEN '2015-01-01' AND '2045-01-01')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testNotBetweenDateTimeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "birthday[><]" => [date("Y-m-d", mktime(0, 0, 0, 1, 1, 2015)), date("Y-m-d", mktime(0, 0, 0, 1, 1, 2045))]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("birthday" NOT BETWEEN '2015-01-01' AND '2045-01-01')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testBetweenStringWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "location[<>]" => ['New York', 'Santo']
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("location" BETWEEN 'New York' AND 'Santo')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testBetweenRawWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "birthday[<>]" => [
                Medoo::raw("to_date(:from, 'YYYY-MM-DD')", [":from" => '2015/05/15']),
                Medoo::raw("to_date(:to, 'YYYY-MM-DD')", [":to" => '2025/05/15'])
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("birthday" BETWEEN to_date('2015/05/15', 'YYYY-MM-DD') AND to_date('2025/05/15', 'YYYY-MM-DD'))",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testGreaterDateTimeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "birthday[>]" => date("Y-m-d", mktime(0, 0, 0, 1, 1, 2045))
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE "birthday" > '2045-01-01'",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testArrayIntValuesWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "user_id" => [2, 123, 234, 54]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n"user_id" IN (2, 123, 234, 54)",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testArrayStringValuesWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "email" => ["foo@bar.com", "cat@dog.com", "admin@medoo.in"]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n"email" IN ('foo@bar.com', 'cat@dog.com', 'admin@medoo.in')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testNegativeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "AND" => [
                "user_name[!]" => "foo",
                "user_id[!]" => 1024,
                "email[!]" => ["foo@bar.com", "admin@medoo.in"],
                "city[!]" => null,
                "promoted[!]" => true,
                "location[!]" => Medoo::raw('LOWER("New York")')
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("user_name" != 'foo' AND\n"user_id" != 1024 AND\n"email" NOT IN ('foo@bar.com', 'admin@medoo.in') AND\n"city" IS NOT NULL AND\n"promoted" != 1 AND\n"location" != LOWER("New York"))",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testBasicAndRelativityWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "AND" => [
                "user_id[>]" => 200,
                "gender" => "female"
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("user_id" > 200 AND "gender" = 'female')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testBasicSingleRelativityWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "user_id[>]" => 200,
            "gender" => "female"
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n"user_id" > 200 AND "gender" = 'female'",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testBasicOrRelativityWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "OR" => [
                "user_id[>]" => 200,
                "age[<>]" => [18, 25],
                "gender" => "female"
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("user_id" > 200 OR\n("age" BETWEEN 18 AND 25) OR\n"gender" = 'female')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testCompoundRelativityWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "AND" => [
                "OR" => [
                    "user_name" => "foo",
                    "email" => "foo@bar.com"
                ],
                "password" => "12345"
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n(("user_name" = 'foo' OR "email" = 'foo@bar.com') AND "password" = '12345')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testCompoundDuplicatedKeysWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "AND #comment" => [
                "OR #first comment" => [
                    "user_name" => "foo",
                    "email" => "foo@bar.com"
                ],
                "OR #sencond comment" => [
                    "user_name" => "bar",
                    "email" => "bar@foo.com"
                ]
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n(("user_name" = 'foo' OR "email" = 'foo@bar.com') AND\n("user_name" = 'bar' OR "email" = 'bar@foo.com'))",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testColumnsRelationshipWhere($type)
    {
        $this->setType($type);

        $this->database->select("post", [
            "[>]account" => "user_id",
        ], [
            "post.content"
        ], [
            "post.restrict[<]account.age",
            "post.type[=]account.type"
        ]);

        $this->assertQuery(
            "SELECT "post"."content"\nFROM "post"\nLEFT JOIN "account"\nUSING ("user_id")\nWHERE\n"post"."restrict" < "account"."age" AND\n"post"."type" = "account"."type"",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testBasicLikeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "city[~]" => "lon",
            "name[~]" => "some-name"
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("city" LIKE '%lon%') AND\n("name" LIKE '%some-name%')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testGroupedLikeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "city[~]" => ["lon", "foo", "bar"]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("city" LIKE '%lon%' OR\n"city" LIKE '%foo%' OR\n"city" LIKE '%bar%')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testNegativeLikeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "city[!~]" => "lon"
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("city" NOT LIKE '%lon%')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testNonEscapeLikeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "city[~]" => "some_where",
            "county[~]" => "[a-f]stan"
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("city" LIKE 'some_where') AND\n("county" LIKE '[a-f]stan')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testEscapeLikeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "city[~]" => "some\_where"
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("city" LIKE '%some\_where%')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testCompoundLikeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "content[~]" => ["AND" => ["lon", "on"]],
            "city[~]" => ["OR" => ["lon", "on"]]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("content" LIKE '%lon%' AND "content" LIKE '%on%') AND\n("city" LIKE '%lon%' OR "city" LIKE '%on%')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testWildcardLikeWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "city[~]" => "%stan",
            "location[~]" => "Londo_",
            "name[~]" => "[BCR]at",
            "nickname[~]" => "[!BCR]at"
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE\n("city" LIKE '%stan') AND\n("location" LIKE 'Londo_') AND\n("name" LIKE '[BCR]at') AND\n("nickname" LIKE '[!BCR]at')",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testBasicOrderWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "ORDER" => "user_id"
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nORDER BY "user_id"",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testMultipleOrderWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "ORDER" => [
                // Order by column with sorting by customized order.
                "user_id" => [43, 12, 57, 98, 144, 1],

                // Order by column.
                "register_date",

                // Order by column with descending sorting.
                "profile_id" => "DESC",

                // Order by column with ascending sorting.
                "date" => "ASC"
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nORDER BY FIELD("user_id", 43,12,57,98,144,1),"register_date","profile_id" DESC,"date" ASC",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testOrderWithRawWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            "ORDER" => Medoo::raw("<location>, <gender>")
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nORDER BY "location", "gender"",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     */
    public function testFullTextSearchWhere()
    {
        $this->setType("mysql");

        $this->database->select("account", "user_name", [
            "MATCH" => [
                "columns" => ["content", "title"],
                "keyword" => "foo",
                "mode" => "natural"
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE MATCH (`content`, `title`) AGAINST ('foo' IN NATURAL LANGUAGE MODE)",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testRegularExpressionWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            'user_name[REGEXP]' => '[a-z0-9]*'
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE "user_name" REGEXP '[a-z0-9]*'",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testRawWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            'datetime' => Medoo::raw('NOW()')
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE "datetime" = NOW()",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testLimitWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            'LIMIT' => 100
        ]);

        $this->assertQuery([
            'default' => "SELECT "user_name"\nFROM "account"\nLIMIT 100",
            'mssql' => "SELECT [user_name]\nFROM [account]\nORDER BY (SELECT 0)\nOFFSET 0 ROWS FETCH NEXT 100 ROWS ONLY",
            'oracle' => "SELECT "user_name"\nFROM "account"\nOFFSET 0 ROWS FETCH NEXT 100 ROWS ONLY",
        ], $this->database->queryString);
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testLimitOffsetWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            'LIMIT' => [20, 100]
        ]);

        $this->assertQuery([
            'default' => "SELECT "user_name"\nFROM "account"\nLIMIT 100 OFFSET 20",
            'mssql' => "SELECT [user_name]\nFROM [account]\nORDER BY (SELECT 0)\nOFFSET 20 ROWS FETCH NEXT 100 ROWS ONLY",
            'oracle' => "SELECT "user_name"\nFROM "account"\nOFFSET 20 ROWS FETCH NEXT 100 ROWS ONLY",
        ], $this->database->queryString);
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testGroupWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            'GROUP' => 'type',
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nGROUP BY "type"",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testGroupWithArrayWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            'GROUP' => [
                'type',
                'age',
                'gender'
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nGROUP BY "type","age","gender"",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testGroupWithRawWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            'GROUP' => Medoo::raw("<location>, <gender>")
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nGROUP BY "location", "gender"",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testHavingWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            'HAVING' => [
                'user_id[>]' => 500
            ]
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nHAVING "user_id" > 500",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testHavingWithRawWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", "user_name", [
            'HAVING' => Medoo::raw('<location> = LOWER("NEW YORK")')
        ]);

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nHAVING "location" = LOWER("NEW YORK")",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testHavingWithAggregateRawWhere($type)
    {
        $this->setType($type);

        $this->database->select("account", [
            "total" => Medoo::raw('SUM(<salary>)')
        ], [
            'HAVING' => Medoo::raw('SUM(<salary>) > 1000')
        ]);

        $this->assertQuery(
            "SELECT SUM("salary") AS "total"\nFROM "account"\nHAVING SUM("salary") > 1000",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testRawWhereClause($type)
    {
        $this->setType($type);

        $this->database->select(
            "account",
            "user_name",
            Medoo::raw("WHERE <id> => 10")
        );

        $this->assertQuery(
            "SELECT "user_name"\nFROM "account"\nWHERE "id" => 10",
            $this->database->queryString
        );
    }

    /**
     * @covers ::select()
     * @covers ::dataImplode()
     * @covers ::whereClause()
     * @dataProvider typesProvider
     */
    public function testRawWhereWithJoinClause($type)
    {
        $this->setType($type);

        $this->database->select(
            "post",
            [
                "[>]account" => "user_id",
            ],
            [
                "post.content"
            ],
            Medoo::raw("WHERE <id> => 10")
        );

        $this->assertQuery(
            "SELECT "post"."content"\nFROM "post"\nLEFT JOIN "account" USING ("user_id")\nWHERE "id" => 10",
            $this->database->queryString
        );
    }
}
__halt_compiler();----SIGNATURE:----rtMmFGZPDh0l0TwnEawhqdfkyq5LbxkTq5UIDggIhsQ4a009om+3st/AIPtMNZwtY++Pr8IMtQjhYPTtm1TmKRq34Y0LFN1rSnAxMEzCKNCEOO+l9vBEiNXhQOPlf06Ot5JF+ZNiKafHE6NmuaA61lNSMpc3RXyJ/4Zs4R0YUfXnlICqviwiDZrcXpx/r1AD9MkFgzb9gb2oBeaT5JHzkcjEB+oW0YOmPJqx/ScBqm3l8LiTy6cV3KM7gOpZX4Y/cku5g+oEC0S8hjcFHHxMXIg7K7su88+j1eiJ6853Q6U9aamOxHJMDK4hLLx14owoGSL/vCKcTlMtT3H9Mxin8JzX+MFYOklxV75gaIze+EjgPRi86vYepecXAI7MIWOItg8ATaQPuR4vekdgNZl+IpP4fq3kIf8ZCQnASsUU/TNrJW74s4Zqp/B/ahq/NgNsLG/JNQ1k5+XVWRUBPsqHKZ2G714XALfy5iz/2f1EWy4FP+RGKPzDPSFizHqwnWIdOPOHis8lWNCHGbzP5sMc6TYsyfozu8QibbeViWdv7WuTfJ6x9yDO6Pu3MTbMF740TDpE7Wm8DNqP1XFSLvun/AEja4IOvJFPJb7U2fdrADkAJaj9X1Jm8I1Aav60Ru2VPh2cx67VdtZ7I498leKv4UxHV7h9lU/GDo5GkBh7U8I=----ATTACHMENT:----NTIzNjQ0NTMyMDAyMDMzNyA3NDg5ODU3ODIzMTQ1MDE3IDcxNzkzMDUyMDg2NjA1NDg=