text:
<?xml version="1.0" encoding="UTF-8"?>

BEBULIN- coagulation factor ix human

Baxter Healthcare Corporation

BEBULIN
(Factor IX Complex),
Nanofiltered and Vapor Heated
Lyophilized
        Powder for Reconstitution for Intravenous Administration

DESCRIPTION

BEBULIN (Factor IX Complex), Nanofiltered and Vapor Heated is a
                            purified, sterile, freeze-dried concentrate of the Coagulation Factor IX
                            (Christmas Factor) as well as Factor II (Prothrombin) and Factor
                            X (Stuart-Prower Factor) and low amounts of Factor VII. In addition, the
                            product contains small amounts of heparin (≤ 0.15 IU heparin per IU
                            Factor IX).

BEBULIN is standardized in terms of Factor IX content and each
                            vial is labeled for the Factor IX content indicated in International
                            Units (IU). One International Unit of Factor IX (according to the
                            current International Standard for Human Blood Coagulation Factors II,
                            IX, and X in concentrates) corresponds to the activity of Factor IX in 1
                            mL of fresh normal human plasma.

BEBULIN is manufactured from large plasma pools of human plasma.
                            Screening against potentially infectious agents begins with the donor
                            selection process and continues throughout plasma collection and plasma
                            preparation. Each individual plasma donation used in the manufacture of
                            BEBULIN is collected only at FDA approved blood establishments and is
                            tested by FDA licensed serological tests for Hepatitis B Surface Antigen
                            (HBsAg), for antibodies to Human Immunodeficiency Virus (HIV-1/HIV-2)
                            and Hepatitis C Virus (HCV) in accordance with U.S. regulatory
                            requirements. As an additional safety measure, mini-pools of the plasma
                            are tested for the presence of HIV-1 and HCV by FDA licensed Nucleic
                            Acid Testing (NAT) and found negative. Validated virus
                            removal/inactivation steps have been integrated into the manufacturing
                            process, namely 35 nm nanofiltration1 and a vapor heat
                            treatment process2 [10 hours at 60°C and subsequent 1 hour at
                            80°C under the condition of 7-8% (w/v) residual moisture]. In addition DEAE-Sephadex adsorption
                            contributes to the virus safety profile of BEBULIN. Despite these
                            measures, this product can still potentially transmit
                                disease3 [see Warnings].

In vitro spiking studies
                            have been used to validate the capability of the manufacturing process
                            to remove and inactivate viruses. To establish virus clearance capacity
                            of the manufacturing process, these virus clearance studies were
                            performed in accordance with good laboratory practices under extreme
                            conditions (e.g. at minimum incubation times and temperatures below
                            specifications for vapor-heat treatment). The in vitro viral reduction studies
                            performed on nanofiltered BEBULIN are summarized in Table 1
                            .

Table 1 Mean
                                    log10 Reduction Factors (RFs) For Each Virus and
                                Manufacturing Step*

<col width="17.2%">
<col width="15.1%">
<col width="14.9%">
<col width="17.2%">
<col width="18.4%">
<col width="17.2%">

*

Reduction factors
                                    < 1 log are not used for calculation of the overall reduction
                                    factor.

†

Studies
                                                on B19V, which are considered experimental in
                                                nature, have demonstrated a virus reduction factor
                                                of not more than 3.6 log10 and 4.6
                                                  log10 by DEAE-Sephadex adsorption and
                                                vapor -heat treatment,
                                            respectively.

‡

HIV-1,
                                                Human Immunodeficiency Virus Type 1
BVDV, Bovine
                                                Viral Diarrhea Virus (model for Hepatitis C Virus
                                                and other lipid enveloped RNA viruses)
PRV,
                                                Pseudorabies Virus (model for lipid enveloped DNA
                                                viruses including Hepatitis B Virus)
HAV,
                                                Hepatitis A Virus
MMV, Mice Minute Virus (model
                                                for non-lipid enveloped DNA viruses, including human
                                                parvovirus B19 [B19V])

§

n.d.: Not
                                            done

¶

Studies on
                                            West Nile Virus (WNV), have demonstrated a virus
                                            reduction factor of 3.1 log10 by the 35 nm
                                            nanofiltration step.

Virus Type
Enveloped RNA
Enveloped DNA
Non-enveloped RNA
Non-enveloped DNA

Virus Family
Retroviridae
Flaviviridae
Herpesviridae
Picornaviridae
Parvoviridae†

Virus‡
HIV-1
BVDV
PRV
HAV
MMV

DEAE Sephadex Adsorption
n.d§

n.d
n.d
1.4
1.3

35
                                        nm Nanofiltration¶

> 6.4
2.0
> 6.0
1.7
≤1.0

Vapor-Heat Treatment
> 6.8
> 7.1
> 7.4
> 4.5
≤1.0

Overall log reduction factor (ORF)
>
                                        13.2
>
                                        9.1
>
                                        13.4
>
                                        7.6
1.3

CLINICAL PHARMACOLOGY

BEBULIN is a combination of vitamin K-dependent clotting factors
                            (Factor IX, II, X) and found in normal plasma. The administration of
                            BEBULIN provides an increase in plasma levels of Factor IX and can
                            temporarily correct the coagulation defect of patients with Factor IX
                            deficiency. Plasma levels of Factors II and X will also be increased.
                            However, no clinical studies have been conducted to show benefit from
                            this product for treating deficiencies other than Factor IX
                            deficiency.

In vivo recovery of BEBULIN was
                            determined using the former International Standard, WHO 72/32 and was
                            found to be 53.3% ±9.6%, 57.5% ±21.8%, and 53.24% ±16.95%, respectively.
                            In the same studies, using different methodologies, half-lives were
                            determined to be 19.4 hrs ±3.8 hrs, 24.6 hrs ±3.2 hrs, and 19.97 hrs
                            ±8.24 hrs, respectively1.

INDICATIONS AND USAGE

BEBULIN is indicated for the prevention and control of bleeding
                            episodes in adult patients with hemophilia B (congenital Factor IX
                            deficiency or Christmas disease).

BEBULIN is not indicated for use in the treatment of Factor VII
                            deficiency. No clinical studies have been conducted to show benefit from
                            this product for treating deficiencies other than Factor IX
                            deficiency.

CONTRAINDICATIONS

BEBULIN is contraindicated in patients with

Known history of hypersensitivity reactions to the product

Known allergy to heparin

Known history of heparin-induced thrombocytopenia

WARNINGS

Thrombosis

Thromboembolic events (deep vein thrombosis, pulmonary
                                    embolism, thrombotic stroke) as well as disseminated
                                    intravascular coagulation (DIC) have been reported with BEBULIN.
                                    The risk of thromboembolic complications including DIC and
                                    hyperfibrinolysis is higher in patients with congenital or
                                    acquired coagulation disorders, with repeated dosing or high
                                    doses of BEBULIN. Because of the risk of thromboembolic
                                    complications, closely monitor patients when administering
                                    BEBULIN:

Monitor patients closely for signs and symptoms of
                                        intravascular coagulation or thrombosis.

Monitor Factor IX level in patients predisposed to
                                        thromboembolic complications including patients with a
                                        history of coronary artery disease, patients with liver
                                        disease, pre- or postoperative patients, and
                                        neonates.

Stop the infusion immediately and initiate appropriate
                                        diagnostic and therapeutic measures at the first signs or
                                        symptoms of thrombosis or embolism.

Anaphylaxis and Hypersensitivity Reactions

Hypersensitivity reactions, including
                                    anaphylactic/anaphylactoid reactions have been reported with
                                    BEBULIN. Manifestations of hypersensitivity or allergic
                                    reactions include anaphylactic shock, hypotension, hypertension,
                                    chest tightness, dizziness, paresthesia, lethargy, restlessness,
                                    vomiting, urticaria, erythema, pyrexia, chills, and rash. In the
                                    event of an anaphylactic/anaphylactoid reaction, stop the
                                    infusion immediately and administer appropriate emergency
                                    treatment. Evaluate patients experiencing allergic reactions for
                                    the presence of an inhibitor.

Development of Inhibitor

Formation of circulating antibodies inhibiting Factor IX
                                    has been reported with the administration of BEBULIN. If such an
                                    inhibitor occurs, the condition will manifest itself as a poor
                                    clinical response. Nephrotic syndrome has been reported
                                    following attempted immune tolerance induction in hemophilia B
                                    with Factor IX inhibitor receiving factor IX products including
                                        BEBULIN.4 The safety and efficacy of using factor
                                    IX products including BEBULIN for immune tolerance induction
                                    have not been established.

Transmission of Infectious Agents

Because BEBULIN is made from human plasma, it may carry a
                                    risk of transmitting infectious agents, e.g., viruses, the
                                    variant Creutzfeldt-Jakob disease (vCJD) agent, and
                                    theoretically, the classic Creutzfeldt-Jakob disease agent. This
                                    also applies to unknown or emerging viruses and other pathogens.
                                    No cases of transmission of viral diseases or vCJD have been
                                    associated with BEBULIN.

ALL infections thought by a physician to possibly have
                                    been transmitted by this product should be reported by the
                                    physician or other healthcare provider to Baxter Healthcare
                                    Corporation, at 1-800-423-2862 (in the U.S.).

PRECAUTIONS

Interference with Heparin Sensitivity Laboratory Testing

BEBULIN contains heparin. Take heparin content into
                                    account when performing clotting tests sensitive to
                                    heparin.

Information for Patients

Inform patients of all signs and symptoms of immediate
                                    hypersensitivity reactions such as fever, urticaria/hives,
                                    rashes, nausea, retching, angioedema/swelling of face or other
                                    body areas, laryngeal edema, stridor, dysphonia,
                                    bronchospasm/wheezing, hypotension, dizziness, lightheadedness,
                                    or loss of consciousness. Advise patients to discontinue use of
                                    the product and contact their physician if these symptoms occur
                                    and seek emergency care immediately for serious
                                    symptoms.

Inform patients of all signs and symptoms of parvovirus
                                    B19 infection, which is especially serious in pregnant women or
                                    immune-compromised individuals. Symptoms of parvovirus B19
                                    infection include fever, drowsiness, chills, and runny nose
                                    followed about two weeks later by a rash and joint pain.

Drug Interactions

No drug interaction studies were performed. The effect of
                                    vitamin K antagonists (e.g. warfarin) can be temporarily
                                    overcome by the administration of human prothrombin complex
                                    products, including BEBULIN, which provides increased plasma
                                    levels of functional vitamin-K dependent coagulation Factors
                                    (II, IX and X)6.

Pregnancy

Pregnancy Category C - Animal reproduction studies have
                                    not been conducted with BEBULIN. It is also not known whether
                                    BEBULIN can cause fetal harm when administered to a pregnant
                                    woman or can affect reproduction capacity.

Pediatric Use

The safety and efficacy of the use of BEBULIN in
                                    pediatric patients have not been established.

ADVERSE REACTIONS

Clinical Trial Experience

Because clinical trials are
                                        conducted under widely varying conditions, adverse reaction
                                        rates observed in the clinical trials of a drug cannot be
                                        directly compared to rates in the clinical trials of another
                                        drug and may not reflect the rates observed in clinical
                                        practice.

The following adverse reactions were reported in clinical
                                    studies with a previous formulation of BEBULIN:

Hypotension, Dizziness, Urticaria, Erythema, Pyrexia, and
                                    Chills.

The formation of inhibitor antibodies to Factor IX has
                                    been observed with the administration of BEBULIN.

Postmarketing Experience

Because postmarketing reporting of
                                        adverse reactions is voluntary and from a population of
                                        uncertain size, it is not always possible to reliably
                                        estimate the frequency of these reactions or establish a
                                        causal relationship to product exposure.

Table 2 lists the adverse reactions reported
                                    during postmarketing use of BEBULIN.

Table 2
                                        Postmarketing Adverse Reactions

<col width="45.3%">
<col width="54.7%">

Blood and Lymphatic System
                                                  Disorders

Disseminated intravascular
                                                  coagulation

Immune System
                                                  Disorders

Anaphylactic/Anaphylactoid
                                                  reactions,
Hypersensitivity

Nervous System
                                                  Disorders
Headache

Cardiac
                                                  Disorders
Tachycardia

Vascular
                                                  Disorders

Thromboembolic
                                                  events (including Deep vein
thrombosis,
                                                Pulmonary embolism, Thrombotic stroke),
                                                Flushing

Respiratory, Thoracic, and
                                                  Mediastinal Disorders

Dyspnea, Bronchospasm, Wheezing,
                                                  Cough

Gastrointestinal
                                                  Disorders

Abdominal pain, Nausea

Skin and Subcutaneous
                                                  Tissue Disorders

Angioedema, Facial edema, Rash,
                                                  Pruritus

Renal and Urinary
                                                  Disorders

Nephrotic
                                                  syndrome (following attempted
immune
                                                tolerance induction)

General Disorders and
                                                  Administration Site Conditions
Infusion site reactions,
                                                including Infusion site pain

In addition to reactions listed above, myocardial
                                    infarction has been identified in the published literature with
                                    other Factor IX products.

DOSAGE AND ADMINISTRATION

For intravenous administration only

One International Unit (IU) of Factor IX activity/kg will
                            increase the plasma level of Factor IX by 0.8%. Accordingly, the
                            following formula is provided for dosage calculations:

Number of Factor IX IU required = bodyweight (kg) x desired
                            Factor IX increase (% of normal) x 1.2.

The response to treatment will vary from patient to patient.
                            Exact dosage determination should be based on localization and extent of
                            hemorrhage, and the level of Factor IX to be achieved. Close laboratory
                            monitoring of the Factor IX level is required to determine proper
                            dosage, particularly with severe hemorrhage and major surgery. Larger
                            doses than those derived from the above formula may be required;
                            particularly if treatment is delayed.

Management of Bleeding 7-11

Approximate desired Factor IX levels, typical initial
                                    doses, and the average duration of treatment are suggested in
                                        Table 3. For minor bleeding, a single dose will
                                    usually be sufficient; otherwise a second dose may be given
                                    after 24 hours. More severe hemorrhage will require several
                                    doses at approximately 24-hours intervals. For maintenance
                                    therapy, usually two thirds of the initial dose is
                                    infused.

Table 3
                                        Management of Specific Types of Bleeding

<col width="27.1%">
<col width="29.0%">
<col width="21.5%">
<col width="22.4%">

*

For
                                                  patients predisposing to thrombosis see Precautions
                                                  section.

Type of Bleeding

ApproximateDesired Factor IX
                                                  Level

(% Normal)

Typical
                                                  InitialDose

(International
                                                  Units/kg)

Average
                                                  Durationof Treatment

(Days)

Minor
Early hemarthrosis,
minor
                                                  epistaxis,
and gingival bleeding, mild
                                                hematuria
20
25-35
1

Moderate
Severe joint bleeding,

early hematoma, major open bleeding, minor
                                                  trauma, minor
                                                hemoptysis,
hematemesis,
and
                                                melena,
major hematuria
40
50-65

2 or until
                                                  adequate
 wound healing

Major
Severe hematoma major trauma,
                                                  Severe hemoptysis,
hematemesis, and

melena
≥60*

75-90

2-3 or until
                                                  adequate
 wound healing

Management of Surgical Procedures 7-11

Dosage guidelines for surgical procedures are suggested
                                    in Table 4. Administer preoperative loading dose
                                    one hour prior to surgery. Depending on the type of surgery,
                                    continue replacement therapy over one to several weeks until
                                    adequate wound healing is achieved. The average treatment
                                    interval will initially be 12 hours, while in the later
                                    postoperative period, 24 hours is adequate.

Table 4
                                        Management of Surgical Procedures

<col width="11.2%">
<col width="18.5%">
<col width="13.1%">
<col width="18.5%">
<col width="9.1%">
<col width="19.4%">
<col width="10.3%">

*

N/A–
                                                  Not Applicable.

†

For
                                                  patients predisposing to thrombosis see Precautions section.

Type ofSurgery

Day of Operation

Init. Postop.
                                                  Period

(1st to 2nd
                                                  Week)

Late Postop.
                                                  Period(from 3rd Week
                                                  Onwards)

Approx. Level Factor IX

(% Normal)

Dose
(IU/kg)

Approx. Level Factor
                                                  IX
 (% Normal)

Dose
(IU/kg)

Approx. Level Factor IX

(% Normal)

Dose
(IU/kg)

Minor
 40-60
 50-75

20-40

25-65

N/A*

N/A*

Major

≥60†

                                                75-90
20-60

                                                25-75

                                                20
 25-35

For tooth extraction, the same initial dose as for minor
                                    surgery is recommended and one infusion should be sufficient. In
                                    case of extraction of several teeth, replacement therapy for up
                                    to one week may be necessary using the same doses as for minor
                                        surgery8-11.

Reconstitution

Do not mix BEBULIN with other medicinal products or
                                        solvents, other than the enclosed sterilized water for
                                        injection.

Administer BEBULIN within 3 hours after reconstitution as
                                        the solution does not contain a preservative. Do not refrigerate after
                                            reconstitution.

Warm unopened vials of both diluent and concentrate to
                                        room temperature (not to exceed 37°C, 98°F).

Remove caps from both vials to expose central portions of
                                        the rubber stoppers.

Cleanse exposed surface of the rubber stoppers with
                                        germicidal solution and allow to dry.

Using aseptic technique, remove protective covering from
                                        one end of the double-ended needle and insert the exposed
                                        end through the diluent vial stopper.

Remove protective covering from the other end of the
                                        double-ended needle. Do not touch the exposed end. Invert
                                        diluent vial over the concentrate vial, then insert free end
                                        of the needle through the concentrate vial stopper. Diluent
                                        will be drawn into the concentrate vial by vacuum.

Disconnect the two vials by removing needle from the
                                        concentrate vial stopper.
Gently agitate or rotate the
                                        concentrate vial until all material is dissolved.

Administration

For Intravenous Administration
                                        Only.

Parenteral drug products should be inspected for
                                        particulate matter and discoloration prior to
                                        administration.

The reconstituted product should be colorless to slightly
                                        yellowish and clear to slightly turbid solution. Do not
                                        administer if particulate matter or discoloration is found
                                        and notify Baxter immediately.

Record the name of the patient and batch number of the
                                        product in order to maintain a link between the patient and
                                        the batch of the product.

After reconstituting the concentrate as described above,
                                        attach the enclosed filter needle to a sterile disposable
                                        syringe using aseptic technique. Insert filter needle
                                        through the concentrate vial stopper.

Inject air and withdraw solution into the syringe.

Remove and discard filter needle. Attach a suitable
                                        intravenous needle or infusion set with winged
                                        adapter.

Administer the solution intravenously at a rate
                                        comfortable to the patient. The infusion rate should not
                                        exceed 2 mL per minute.

HOW SUPPLIED

BEBULIN is supplied in single dose vials (NDC 64193-445-02) with
                            Sterile Water for Injection, U.S.P., double-ended needle, and filter
                            needle for reconstitution and withdrawal. Factor IX activity in
                            international units is stated on the label of each vial.

STORAGE

Store at refrigerated temperature (2°C-8°C, 35°F-46°F).
                                    Do not use BEBULIN past the expiration date printed on the unit
                                    carton. Do not freeze.

REFERENCES

T. Abe et al.: Clinical Study with BENOBIL
                                TIM 4, Steam-Treated Factor IX Complex, Single Administration. Jap.
                                Pharm. & Ther., 14, 1986, 1, pp. 19-31.

Vapor Heating is described in: World Health Organization (WHO)
                                Technical Report, Series No. 924, 2004, Annex 4, Guidelines on viral
                                inactivation and removal, procedures intended to assure the viral
                                safety, of human blood plasma products.

 D.U. Preiss, B. Eberspächer, D. Abdullah, I. Rosner: Safety of
                                Vapour Heated Prothrombin Complex Concentrate (PCC) Prothromplex
                                S-TIM4. Thrombosis Research, 63, 1991, pp. 651-659.

I. Warrier: Management of haemophilia B patients with inhibitors
                                and anaphylaxis. Haemophilia, 4 (4), pp.574-576.

A. Shapiro, T. Abe, L. M. Aledort, K. Anderle, M. W. Hilgartner,
                                M. Kunschak,
F. E. Preston, G. E. Rivard, K. Schimpf and
                                International Factor Safety Study Group: Transfusion, 35, 1995, pp
                                204-208.

Ansell J, Hirsch J, Hylek E, Jacobson A, Crowther M, Palareti G.
                                Pharmacology and management of the vitamin K antagonists: American
                                College of Chest Physicians Evidence-Based Clinical Practice
                                Guidelines (8th ed). Chest 2008, 133:160S-198S.

P. H. Levine: Clinical Manifestations and Therapy of Hemophilias A
                                and B. In: R. W. Colman, J. Hirsh, V. J. Marder, E.W. Salzman
                                (Eds.): Hemostasis and Thrombosis. Philadelphia: J. B. Lippincott
                                Company, 1987, pp. 97-111.

C. R. Rizza, P. Jones: Management of patients with inherited blood
                                coagulation defects. In: A.L. Bloom, D.P. Thomas (Eds.): Hemostasis
                                and Thrombosis. Edinburgh: Churchill Livingstone, 1987, pp.
                                465-493.

T. Abe, M. Kazama: An International Survey on the Appropriate
                                Dosage of Hemophilias and Related Congenital Coagulopathies. In:
                                Proceedings of the 3rd International Symposium on Haemostasis and
                                Thrombosis, 1982, pp. 273-304.

I. M. Nilsson, Å. Ahlberg, G. Björlin: Clinical Experience with a
                                Swedish Factor IX Concentrate. Acta Med. Scand., 190, 1971, pp.
                                257-266.

J. N. George, R. T. Breckenridge: The Use of Factor VIII and
                                Factor IX Concentrates During Surgery. JAMA, 214, 1970, 9, pp.
                                1673-1676.

To enroll in the confidential, Industry-wide Patient Notification
                            System, call 1 888-873-2838.

Baxter and Bebulin are trademarks of Baxter International Inc.,
                            its subsidiaries or affiliates.

Baxter Healthcare Corporation

Westlake Village, CA-91362

USA

U.S. License No.
                            140                                            Revised: Jul
                            2012

Principle Display Panel

BEBULIN unit
                                carton for 200-1200 potency ranges

20 mL size, dried

NDC 64193-445-02

Factor IX Complex

BEBULIN

Nanofiltered and Vapor Heated

BAXTER

For Intravenous Use Only

WARNING: Human plasma
                            product. Human blood and its components may transmit infectious agents.
                            The physician and patient should discuss the risks and benefits of this
                            product.

Some components of the packaging material contain Dry Natural
                            Rubber Latex.

Rx Only

BEBULIN is a trademark of Baxter AG, Vienna, Austria: Baxter is a
                            trademark of Baxter International Inc., registered in the U.S. Patent
                            and Trademark Office.

BEBULIN vial label
                                for 200-1200 potency ranges

20 mL size, dried

NDC 64193-345-01

Factor IX Complex

BEBULIN

Nanofiltered and Vapor Heated

BAXTER

For Intravenous Use Only

Rx Only

Directions for use: see package insert

Store between 2º and 8ºC (35º and 46ºF).

Reconstitute with 20 mL of Sterile Water for
                            Injection

Baxter and Bebulin are trademarks of Baxter International Inc,
                            Its subsidiaries or affiliates

Baxter Healthcare Corporation

Westlake Village, CA 91362 USA

U.S. License No. 140

20 mL Sterile
                                Water for Injection vial label

NDC 0338-0764-62

Nonpyrogenic

Single-Dose Container

20 mL

Sterile Water for Injection, USP for
                                reconstitution of accompanying product

Do not use unless clear. No antimicrobial agent or other
                            substances has been added. Do not use for intravascular injection
                            without making approximately isotonic by addition of suitable solute.
                            Discard unused portion. Rx Only.

BAXTER

Manufactured by

Baxter Healthcare Corporation

Deerfield, IL 60015 USA

BEBULIN

coagulation factor ix human kit

Product Information

Product Type
PLASMA DERIVATIVE
Item Code (Source)
NDC:64193-445

Packaging

#
Item Code
Package Description
Marketing Start Date
Marketing End Date

1
NDC:64193-445-02
1  in 1 CARTON

Quantity of Parts

Part #
Package Quantity
Total Product Quantity

Part 1
1 VIAL, GLASS
20 mL

Part 2
1 VIAL, GLASS
20 mL

Part 1 of 2

BEBULIN

coagulation factor ix human injection, powder, lyophilized, for solution

Product Information

Item Code (Source)
NDC:64193-345

Route of Administration
INTRAVENOUS
DEA Schedule

Active Ingredient/Active Moiety

Ingredient Name
Basis of Strength
Strength

COAGULATION FACTOR IX HUMAN (COAGULATION FACTOR IX HUMAN)
COAGULATION FACTOR IX HUMAN
300 [iU]  in 1 mL

Inactive Ingredients

Ingredient Name
Strength

SODIUM CITRATE

SODIUM CHLORIDE

HEPARIN

Packaging

#
Item Code
Package Description
Marketing Start Date
Marketing End Date

1
NDC:64193-345-01
20 mL in 1 VIAL, GLASS

Marketing Information

Marketing Category
Application Number or Monograph Citation
Marketing Start Date
Marketing End Date

BLA
BLA103112
08/19/1992

Part 2 of 2

STERILE WATER

water liquid

Product Information

Item Code (Source)
NDC:0338-0764

Route of Administration
INTRAVENOUS
DEA Schedule

Inactive Ingredients

Ingredient Name
Strength

WATER
20 mL  in 20 mL

Packaging

#
Item Code
Package Description
Marketing Start Date
Marketing End Date

1
NDC:0338-0764-62
20 mL in 1 VIAL, GLASS

Marketing Information

Marketing Category
Application Number or Monograph Citation
Marketing Start Date
Marketing End Date

BLA
BLA103112
08/19/1992

Marketing Information

Marketing Category
Application Number or Monograph Citation
Marketing Start Date
Marketing End Date

BLA
BLA103112
08/19/1992

Labeler - Baxter Healthcare Corporation
							(085206634)

Establishment

Name
Address
ID/FEI
Business Operations

Baxter Healthcare Corporation

001728059
MANUFACTURE

Revised: 7/2012

Document Id: bc12b9b9-c06d-447f-b08e-77907c357bfd

Set id: b375a2fb-7bd4-486c-87f6-72237713d528

Version: 7

Effective Time: 20120706

Baxter Healthcare Corporation


text:
from nose.tools import *  # flake8: noqa

from framework.auth.core import Auth

from website.models import Node, NodeLog
from website.util import permissions
from website.util.sanitize import strip_html

from api.base.settings.defaults import API_BASE

from tests.base import ApiTestCase, fake
from tests.factories import (
    NodeFactory,
    ProjectFactory,
    RegistrationFactory,
    AuthUserFactory,
    RetractedRegistrationFactory
)

class TestNodeChildrenList(ApiTestCase):
    def setUp(self):
        super(TestNodeChildrenList, self).setUp()
        self.user = AuthUserFactory()
        self.project = ProjectFactory()
        self.project.add_contributor(self.user, permissions=[permissions.READ, permissions.WRITE])
        self.project.save()
        self.component = NodeFactory(parent=self.project, creator=self.user)
        self.pointer = ProjectFactory()
        self.project.add_pointer(self.pointer, auth=Auth(self.user), save=True)
        self.private_project_url = '/{}nodes/{}/children/'.format(API_BASE, self.project._id)

        self.public_project = ProjectFactory(is_public=True, creator=self.user)
        self.public_project.save()
        self.public_component = NodeFactory(parent=self.public_project, creator=self.user, is_public=True)
        self.public_project_url = '/{}nodes/{}/children/'.format(API_BASE, self.public_project._id)

        self.user_two = AuthUserFactory()

    def test_node_children_list_does_not_include_pointers(self):
        res = self.app.get(self.private_project_url, auth=self.user.auth)
        assert_equal(len(res.json['data']), 1)

    def test_return_public_node_children_list_logged_out(self):
        res = self.app.get(self.public_project_url)
        assert_equal(res.status_code, 200)
        assert_equal(res.content_type, 'application/vnd.api+json')
        assert_equal(len(res.json['data']), 1)
        assert_equal(res.json['data'][0]['id'], self.public_component._id)

    def test_return_public_node_children_list_logged_in(self):
        res = self.app.get(self.public_project_url, auth=self.user_two.auth)
        assert_equal(res.status_code, 200)
        assert_equal(res.content_type, 'application/vnd.api+json')
        assert_equal(len(res.json['data']), 1)
        assert_equal(res.json['data'][0]['id'], self.public_component._id)

    def test_return_private_node_children_list_logged_out(self):
        res = self.app.get(self.private_project_url, expect_errors=True)
        assert_equal(res.status_code, 401)
        assert 'detail' in res.json['errors'][0]

    def test_return_private_node_children_list_logged_in_contributor(self):
        res = self.app.get(self.private_project_url, auth=self.user.auth)
        assert_equal(res.status_code, 200)
        assert_equal(res.content_type, 'application/vnd.api+json')
        assert_equal(len(res.json['data']), 1)
        assert_equal(res.json['data'][0]['id'], self.component._id)

    def test_return_private_node_children_list_logged_in_non_contributor(self):
        res = self.app.get(self.private_project_url, auth=self.user_two.auth, expect_errors=True)
        assert_equal(res.status_code, 403)
        assert 'detail' in res.json['errors'][0]

    def test_node_children_list_does_not_include_unauthorized_projects(self):
        private_component = NodeFactory(parent=self.project)
        res = self.app.get(self.private_project_url, auth=self.user.auth)
        assert_equal(len(res.json['data']), 1)

    def test_node_children_list_does_not_include_deleted(self):
        child_project = NodeFactory(parent=self.public_project, creator=self.user)
        child_project.save()

        res = self.app.get(self.public_project_url, auth=self.user.auth)
        assert_equal(res.status_code, 200)
        ids = [node['id'] for node in res.json['data']]
        assert_in(child_project._id, ids)
        assert_equal(2, len(ids))

        child_project.is_deleted = True
        child_project.save()

        res = self.app.get(self.public_project_url, auth=self.user.auth)
        assert_equal(res.status_code, 200)
        ids = [node['id'] for node in res.json['data']]
        assert_not_in(child_project._id, ids)
        assert_equal(1, len(ids))

    def test_node_children_list_does_not_include_node_links(self):
        pointed_to = ProjectFactory(is_public=True)

        self.public_project.add_pointer(pointed_to, auth=Auth(self.public_project.creator))

        res = self.app.get(self.public_project_url, auth=self.user.auth)
        ids = [node['id'] for node in res.json['data']]
        assert_in(self.public_component._id, ids)  # sanity check

        assert_equal(len(ids), len([e for e in self.public_project.nodes if e.primary]))
        assert_not_in(pointed_to._id, ids)

    def test_cannot_access_retracted_children(self):
        registration = RegistrationFactory(creator=self.user, project=self.public_project)
        retraction = RetractedRegistrationFactory(registration=registration, user=self.user)
        url = '/{}nodes/{}/children/'.format(API_BASE, registration._id)
        res = self.app.get(url, auth=self.user.auth, expect_errors=True)
        assert_equal(res.status_code, 403)

class TestNodeChildrenListFiltering(ApiTestCase):

    def test_node_child_filtering(self):
        user = AuthUserFactory()
        project = ProjectFactory(creator=user)

        title1, title2 = fake.bs(), fake.bs()
        component = NodeFactory(title=title1, parent=project)
        component2 = NodeFactory(title=title2, parent=project)

        url = '/{}nodes/{}/children/?filter[title]={}'.format(
            API_BASE,
            project._id,
            title1
        )
        res = self.app.get(url, auth=user.auth)

        ids = [node['id'] for node in res.json['data']]

        assert_in(component._id, ids)
        assert_not_in(component2._id, ids)

class TestNodeChildCreate(ApiTestCase):

    def setUp(self):
        super(TestNodeChildCreate, self).setUp()

        self.user = AuthUserFactory()
        self.user_two = AuthUserFactory()

        self.project = ProjectFactory(creator=self.user, is_public=True)

        self.url = '/{}nodes/{}/children/'.format(API_BASE, self.project._id)
        self.child = {
            'data': {
                'type': 'nodes',
                'attributes': {
                    'title': 'child',
                    'description': 'this is a child project',
                    'category': 'project'
                }
            }
        }

    def test_creates_child_logged_out_user(self):
        res = self.app.post_json_api(self.url, self.child, expect_errors=True)
        assert_equal(res.status_code, 401)

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

    def test_creates_child_logged_in_owner(self):
        res = self.app.post_json_api(self.url, self.child, auth=self.user.auth)
        assert_equal(res.status_code, 201)
        assert_equal(res.json['data']['attributes']['title'], self.child['data']['attributes']['title'])
        assert_equal(res.json['data']['attributes']['description'], self.child['data']['attributes']['description'])
        assert_equal(res.json['data']['attributes']['category'], self.child['data']['attributes']['category'])

        self.project.reload()
        assert_equal(res.json['data']['id'], self.project.nodes[0]._id)
        assert_equal(self.project.nodes[0].logs[0].action, NodeLog.PROJECT_CREATED)

    def test_creates_child_logged_in_write_contributor(self):
        self.project.add_contributor(self.user_two, permissions=[permissions.READ, permissions.WRITE], auth=Auth(self.user), save=True)

        res = self.app.post_json_api(self.url, self.child, auth=self.user_two.auth)
        assert_equal(res.status_code, 201)
        assert_equal(res.json['data']['attributes']['title'], self.child['data']['attributes']['title'])
        assert_equal(res.json['data']['attributes']['description'], self.child['data']['attributes']['description'])
        assert_equal(res.json['data']['attributes']['category'], self.child['data']['attributes']['category'])

        self.project.reload()
        child_id = res.json['data']['id']
        assert_equal(child_id, self.project.nodes[0]._id)
        assert_equal(Node.load(child_id).logs[0].action, NodeLog.PROJECT_CREATED)

    def test_creates_child_logged_in_read_contributor(self):
        self.project.add_contributor(self.user_two, permissions=[permissions.READ], auth=Auth(self.user), save=True)
        res = self.app.post_json_api(self.url, self.child, auth=self.user_two.auth, expect_errors=True)
        assert_equal(res.status_code, 403)

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

    def test_creates_child_logged_in_non_contributor(self):
        res = self.app.post_json_api(self.url, self.child, auth=self.user_two.auth, expect_errors=True)
        assert_equal(res.status_code, 403)

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

    def test_creates_child_creates_child_and_sanitizes_html_logged_in_owner(self):
        title = 'Cool Project'
        description = 'An  child'

        res = self.app.post_json_api(self.url, {
            'data': {
                'type': 'nodes',
                'attributes': {
                    'title': title,
                    'description': description,
                    'category': 'project',
                    'public': True
                }
            }
        }, auth=self.user.auth)
        child_id = res.json['data']['id']
        assert_equal(res.status_code, 201)
        url = '/{}nodes/{}/'.format(API_BASE, child_id)

        res = self.app.get(url, auth=self.user.auth)
        assert_equal(res.json['data']['attributes']['title'], strip_html(title))
        assert_equal(res.json['data']['attributes']['description'], strip_html(description))
        assert_equal(res.json['data']['attributes']['category'], 'project')

        self.project.reload()
        child_id = res.json['data']['id']
        assert_equal(child_id, self.project.nodes[0]._id)
        assert_equal(Node.load(child_id).logs[0].action, NodeLog.PROJECT_CREATED)

    def test_cannot_create_child_on_a_registration(self):
        registration = RegistrationFactory(project=self.project, creator=self.user)
        url = '/{}nodes/{}/children/'.format(API_BASE, registration._id)
        res = self.app.post_json_api(url, {
            'data': {
                'type': 'nodes',
                'attributes': {
                    'title': fake.catch_phrase(),
                    'description': fake.bs(),
                    'category': 'project',
                    'public': True,
                }
            }
        }, auth=self.user.auth, expect_errors=True)
        assert_equal(res.status_code, 403)

    def test_creates_child_no_type(self):
        child = {
            'data': {
                'attributes': {
                'title': 'child',
                'description': 'this is a child project',
                'category': 'project',
                }
            }
        }
        res = self.app.post_json_api(self.url, child, auth=self.user.auth, expect_errors=True)
        assert_equal(res.status_code, 400)
        assert_equal(res.json['errors'][0]['detail'], 'This field may not be null.')
        assert_equal(res.json['errors'][0]['source']['pointer'], '/data/type')

    def test_creates_child_incorrect_type(self):
        child = {
            'data': {
                'type': 'Wrong type.',
                'attributes': {
                    'title': 'child',
                    'description': 'this is a child project',
                    'category': 'project',
                }
            }
        }
        res = self.app.post_json_api(self.url, child, auth=self.user.auth, expect_errors=True)
        assert_equal(res.status_code, 409)
        assert_equal(res.json['errors'][0]['detail'], 'Resource identifier does not match server endpoint.')

    def test_creates_child_properties_not_nested(self):
        child = {
            'data': {
                'title': 'child',
                'description': 'this is a child project',
                'category': 'project',
            }
        }
        res = self.app.post_json_api(self.url, child, auth=self.user.auth, expect_errors=True)
        assert_equal(res.status_code, 400)
        assert_equal(res.json['errors'][0]['detail'], 'Request must include /data/attributes.')
        assert_equal(res.json['errors'][0]['source']['pointer'], '/data/attributes')

class TestNodeChildrenBulkCreate(ApiTestCase):

    def setUp(self):
        super(TestNodeChildrenBulkCreate, self).setUp()

        self.user = AuthUserFactory()
        self.user_two = AuthUserFactory()

        self.project = ProjectFactory(creator=self.user, is_public=True)

        self.url = '/{}nodes/{}/children/'.format(API_BASE, self.project._id)
        self.child = {
                'type': 'nodes',
                'attributes': {
                    'title': 'child',
                    'description': 'this is a child project',
                    'category': 'project'
                }
        }
        self.child_two = {
                'type': 'nodes',
                'attributes': {
                    'title': 'second child',
                    'description': 'this is my hypothesis',
                    'category': 'hypothesis'
                }
        }

    def test_bulk_children_create_blank_request(self):
        res = self.app.post_json_api(self.url, auth=self.user.auth, expect_errors=True, bulk=True)
        assert_equal(res.status_code, 400)

    def test_bulk_creates_children_limits(self):
        res = self.app.post_json_api(self.url, {'data': [self.child] * 11},
                                     auth=self.user.auth, expect_errors=True, bulk=True)
        assert_equal(res.status_code, 400)
        assert_equal(res.json['errors'][0]['detail'], 'Bulk operation limit is 10, got 11.')
        assert_equal(res.json['errors'][0]['source']['pointer'], '/data')

    def test_bulk_creates_children_logged_out_user(self):
        res = self.app.post_json_api(self.url, {'data': [self.child, self.child_two]}, expect_errors=True, bulk=True)
        assert_equal(res.status_code, 401)

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

    def test_bulk_creates_children_logged_in_owner(self):
        res = self.app.post_json_api(self.url, {'data': [self.child, self.child_two]}, auth=self.user.auth, bulk=True)
        assert_equal(res.status_code, 201)
        assert_equal(res.json['data'][0]['attributes']['title'], self.child['attributes']['title'])
        assert_equal(res.json['data'][0]['attributes']['description'], self.child['attributes']['description'])
        assert_equal(res.json['data'][0]['attributes']['category'], self.child['attributes']['category'])
        assert_equal(res.json['data'][1]['attributes']['title'], self.child_two['attributes']['title'])
        assert_equal(res.json['data'][1]['attributes']['description'], self.child_two['attributes']['description'])
        assert_equal(res.json['data'][1]['attributes']['category'], self.child_two['attributes']['category'])

        self.project.reload()
        assert_equal(res.json['data'][0]['id'], self.project.nodes[0]._id)
        assert_equal(res.json['data'][1]['id'], self.project.nodes[1]._id)

        assert_equal(self.project.nodes[0].logs[0].action, NodeLog.PROJECT_CREATED)
        assert_equal(self.project.nodes[1].logs[0].action, NodeLog.PROJECT_CREATED)

    def test_bulk_creates_children_child_logged_in_write_contributor(self):
        self.project.add_contributor(self.user_two, permissions=[permissions.READ, permissions.WRITE], auth=Auth(self.user), save=True)

        res = self.app.post_json_api(self.url, {'data': [self.child, self.child_two]}, auth=self.user_two.auth, bulk=True)
        assert_equal(res.status_code, 201)
        assert_equal(res.json['data'][0]['attributes']['title'], self.child['attributes']['title'])
        assert_equal(res.json['data'][0]['attributes']['description'], self.child['attributes']['description'])
        assert_equal(res.json['data'][0]['attributes']['category'], self.child['attributes']['category'])
        assert_equal(res.json['data'][1]['attributes']['title'], self.child_two['attributes']['title'])
        assert_equal(res.json['data'][1]['attributes']['description'], self.child_two['attributes']['description'])
        assert_equal(res.json['data'][1]['attributes']['category'], self.child_two['attributes']['category'])

        self.project.reload()
        child_id = res.json['data'][0]['id']
        child_two_id = res.json['data'][1]['id']
        assert_equal(child_id, self.project.nodes[0]._id)
        assert_equal(child_two_id, self.project.nodes[1]._id)

        assert_equal(Node.load(child_id).logs[0].action, NodeLog.PROJECT_CREATED)
        assert_equal(self.project.nodes[1].logs[0].action, NodeLog.PROJECT_CREATED)

    def test_bulk_creates_children_logged_in_read_contributor(self):
        self.project.add_contributor(self.user_two, permissions=[permissions.READ], auth=Auth(self.user), save=True)
        res = self.app.post_json_api(self.url, {'data': [self.child, self.child_two]}, auth=self.user_two.auth,
                                     expect_errors=True, bulk=True)
        assert_equal(res.status_code, 403)

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

    def test_bulk_creates_children_logged_in_non_contributor(self):
        res = self.app.post_json_api(self.url, {'data': [self.child, self.child_two]},
                                     auth=self.user_two.auth, expect_errors=True, bulk=True)
        assert_equal(res.status_code, 403)

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

    def test_bulk_creates_children_and_sanitizes_html_logged_in_owner(self):
        title = 'Cool Project'
        description = 'An  child'

        res = self.app.post_json_api(self.url, {
            'data': [{
                'type': 'nodes',
                'attributes': {
                    'title': title,
                    'description': description,
                    'category': 'project',
                    'public': True
                }
            }]
        }, auth=self.user.auth, bulk=True)
        child_id = res.json['data'][0]['id']
        assert_equal(res.status_code, 201)
        url = '/{}nodes/{}/'.format(API_BASE, child_id)

        res = self.app.get(url, auth=self.user.auth)
        assert_equal(res.json['data']['attributes']['title'], strip_html(title))
        assert_equal(res.json['data']['attributes']['description'], strip_html(description))
        assert_equal(res.json['data']['attributes']['category'], 'project')

        self.project.reload()
        child_id = res.json['data']['id']
        assert_equal(child_id, self.project.nodes[0]._id)
        assert_equal(Node.load(child_id).logs[0].action, NodeLog.PROJECT_CREATED)

    def test_cannot_bulk_create_children_on_a_registration(self):
        registration = RegistrationFactory(project=self.project, creator=self.user)
        url = '/{}nodes/{}/children/'.format(API_BASE, registration._id)
        res = self.app.post_json_api(url, {
            'data': [self.child_two, {
                'type': 'nodes',
                'attributes': {
                    'title': fake.catch_phrase(),
                    'description': fake.bs(),
                    'category': 'project',
                    'public': True,
                }
            }]
        }, auth=self.user.auth, expect_errors=True, bulk=True)
        assert_equal(res.status_code, 403)

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

    def test_bulk_creates_children_no_type(self):
        child = {
            'data': [self.child_two, {
                'attributes': {
                'title': 'child',
                'description': 'this is a child project',
                'category': 'project',
                }
            }]
        }
        res = self.app.post_json_api(self.url, child, auth=self.user.auth, expect_errors=True, bulk=True)
        assert_equal(res.status_code, 400)
        assert_equal(res.json['errors'][0]['detail'], 'This field may not be null.')
        assert_equal(res.json['errors'][0]['source']['pointer'], '/data/1/type')

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

    def test_bulk_creates_children_incorrect_type(self):
        child = {
            'data': [self.child_two, {
                'type': 'Wrong type.',
                'attributes': {
                    'title': 'child',
                    'description': 'this is a child project',
                    'category': 'project',
                }
            }]
        }
        res = self.app.post_json_api(self.url, child, auth=self.user.auth, expect_errors=True, bulk=True)
        assert_equal(res.status_code, 409)
        assert_equal(res.json['errors'][0]['detail'], 'Resource identifier does not match server endpoint.')

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

    def test_bulk_creates_children_properties_not_nested(self):
        child = {
            'data': [self.child_two, {
                'title': 'child',
                'description': 'this is a child project',
                'category': 'project',
            }]
        }
        res = self.app.post_json_api(self.url, child, auth=self.user.auth, expect_errors=True, bulk=True)
        assert_equal(res.status_code, 400)
        assert_equal(res.json['errors'][0]['detail'], 'Request must include /data/attributes.')
        assert_equal(res.json['errors'][0]['source']['pointer'], '/data/attributes')

        self.project.reload()
        assert_equal(len(self.project.nodes), 0)

redpajama_set_name: RedPajamaGithub


text:
{% extends 'admin/model/list.html' %}
{% import 'admin/model/layout.html' as model_layout with context %}
{% block tail %}
{{ super() }}
  <script src="{{url_for('static', filename='admin/maps.js')}}"></script>
{% endblock %}


text:
import * as React from 'react';

interface ShowSecondsFormState {
    showSeconds: boolean;
}

interface ShowSecondsFormProps {
    showSeconds: boolean;
    setShowSeconds: (showSeconds: boolean) => void; // setShowSeconds(showSeconds: boolean) {
}

class ShowSecondsForm extends React.Component<ShowSecondsFormProps, ShowSecondsFormState> {
    constructor(props: ShowSecondsFormProps) {
        super(props);
        this.state = {
            showSeconds: this.props.showSeconds
        };
        this.updateShowSeconds = this.updateShowSeconds.bind(this);
        this.setLocalShowSeconds = this.setLocalShowSeconds.bind(this);
    }
    setLocalShowSeconds(evt: React.SyntheticEvent<HTMLInputElement>) {
        this.setState({ showSeconds: evt.currentTarget.checked }, this.updateShowSeconds);
    }
    updateShowSeconds() {
        this.props.setShowSeconds(this.state.showSeconds);
    }
    render() {
        return (
            <input type="checkbox" onChange={this.setLocalShowSeconds} checked={this.state.showSeconds} />
        );
    }
}

export default ShowSecondsForm;


text:
package utils;

import java.util.Calendar;

import org.junit.Test;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;

import com.leeo.utils.DateUtils;

public class CommTest {

    public static void main(String[] args) {

    }

    @Test
    public void calendar(){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(DateUtils.string2Date("2016-01-31"));
        calendar.add(Calendar.MONTH, 1);
        calendar.add(Calendar.DAY_OF_YEAR, 1);
        calendar.add(Calendar.YEAR, 1);
        System.out.println(DateUtils.Date2String(calendar.getTime(),DateUtils.DateFormat.DATE_TIME_LA));
    }

    @Test
    public void springPathMatcher(){
        PathMatcher pathMatcher = new AntPathMatcher();
        boolean flag = pathMatcher.match("/websocket/**", "/websocket/123/hcy");
        System.out.println(flag);
    }
}


text:
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.prestosql.sql.planner;

import io.prestosql.metadata.FunctionMetadata;
import io.prestosql.metadata.Metadata;
import io.prestosql.metadata.ResolvedFunction;
import io.prestosql.sql.tree.DefaultExpressionTraversalVisitor;
import io.prestosql.sql.tree.Expression;
import io.prestosql.sql.tree.FunctionCall;

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Function;

import static java.util.Objects.requireNonNull;

/**
 * Determines whether a given Expression is deterministic
 */
public final class DeterminismEvaluator
{
    private DeterminismEvaluator() {}

    public static boolean isDeterministic(Expression expression, Metadata metadata)
    {
        return isDeterministic(
                expression, functionCall -> {
                    ResolvedFunction resolvedFunction = ResolvedFunction.fromQualifiedName(functionCall.getName())
                            .orElseThrow(() -> new IllegalArgumentException("Function call is not resolved: " + functionCall));
                    return metadata.getFunctionMetadata(resolvedFunction);
                });
    }

    public static boolean isDeterministic(Expression expression, Function<FunctionCall, FunctionMetadata> functionMetadataSupplier)
    {
        requireNonNull(functionMetadataSupplier, "functionMetadataSupplier is null");
        requireNonNull(expression, "expression is null");

        AtomicBoolean deterministic = new AtomicBoolean(true);
        new Visitor(functionMetadataSupplier).process(expression, deterministic);
        return deterministic.get();
    }

    private static class Visitor
            extends DefaultExpressionTraversalVisitor<AtomicBoolean>
    {
        private final Function<FunctionCall, FunctionMetadata> functionMetadataSupplier;

        public Visitor(Function<FunctionCall, FunctionMetadata> functionMetadataSupplier)
        {
            this.functionMetadataSupplier = functionMetadataSupplier;
        }

        @Override
        protected Void visitFunctionCall(FunctionCall node, AtomicBoolean deterministic)
        {
            if (!functionMetadataSupplier.apply(node).isDeterministic()) {
                deterministic.set(false);
            }
            return super.visitFunctionCall(node, deterministic);
        }
    }
}


text:
namespace WinUX.Xaml.Converters
{
    using System;

    using Windows.UI.Xaml;
    using Windows.UI.Xaml.Data;

    /// <summary>
    /// Defines a value converter for providing a value if a <see cref="string"/> is empty.
    /// </summary>
    public sealed class EmptyStringFormatConverter : DependencyObject, IValueConverter
    {
        /// <summary>
        /// Defines the dependency property for <see cref="EmptyStringValue"/>.
        /// </summary>
        public static readonly DependencyProperty EmptyStringValueProperty =
            DependencyProperty.Register(
                nameof(EmptyStringValue),
                typeof(string),
                typeof(EmptyStringFormatConverter),
                new PropertyMetadata("No value"));

        /// <summary>
        /// Gets or sets the value to show when the value is empty.
        /// </summary>
        public string EmptyStringValue
        {
            get
            {
                return (string)this.GetValue(EmptyStringValueProperty);
            }
            set
            {
                this.SetValue(EmptyStringValueProperty, value);
            }
        }

        /// <summary>
        /// Checks whether the specified <see cref="value"/> is empty or null to return the <see cref="EmptyStringValue"/>.
        /// </summary>
        /// <param name="value">
        /// The value.
        /// </param>
        /// <param name="targetType">
        /// The target type.
        /// </param>
        /// <param name="parameter">
        /// The parameter.
        /// </param>
        /// <param name="language">
        /// The language.
        /// </param>
        /// <returns>
        /// Returns the <see cref="EmptyStringValue"/> if the <see cref="value"/> is empty.
        /// </returns>
        public object Convert(object value, Type targetType, object parameter, string language)
        {
            if (value == null)
            {
                return this.EmptyStringValue;
            }

            var val = value.ToString();

            return string.IsNullOrWhiteSpace(val) ? this.EmptyStringValue : val;
        }

        /// <summary>
        /// Convert back is not supported by the <see cref="EmptyStringFormatConverter"/>.
        /// </summary>
        public object ConvertBack(object value, Type targetType, object parameter, string language)
        {
            return DependencyProperty.UnsetValue;
        }
    }
}


text:
// __BEGIN_LICENSE__
//  Copyright (c) 2006-2013, United States Government as represented by the
//  Administrator of the National Aeronautics and Space Administration. All
//  rights reserved.
//
//  The NASA Vision Workbench is licensed under the Apache License,
//  Version 2.0 (the "License"); you may not use this file except in
//  compliance with the License. You may obtain a copy of the License at
//  http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
// __END_LICENSE__

/// \file LinescanModel.h
///
/// A generic linescan camera model object
///
///
#ifndef _VW_CAMERA_LINESCAN_MODEL_H_
#define _VW_CAMERA_LINESCAN_MODEL_H_

#include <vw/Math/Quaternion.h>
#include <vw/Camera/CameraModel.h>

namespace vw {
namespace camera {

  template <class PositionFuncT, class PoseFuncT>
  class LinescanModel : public CameraModel {

    // Extrinsics
    PositionFuncT m_position_func;
    PoseFuncT m_pose_func;

    // Intrinsics
    int m_number_of_lines;
    int m_samples_per_line;
    int m_sample_offset;
    double m_focal_length;
    double m_across_scan_pixel_size;
    double m_along_scan_pixel_size;
    std::vector<double> m_line_times;
    Vector3 m_pointing_vec;
    Vector3 m_u_vec;

  public:
    //------------------------------------------------------------------
    // Constructors / Destructors
    //------------------------------------------------------------------

    /// This version of the constructor assumes that the line
    /// integration varies one each scanline of the image.  The
    /// line_integration_times vector must be equal to the
    /// number_of_lines
    LinescanModel( int number_of_lines,
                   int samples_per_line,
                   int sample_offset,
                   double focal_length,
                   double along_scan_pixel_size,
                   double across_scan_pixel_size,
                   std::vector<double> const& line_times,
                   Vector3 pointing_vec,
                   Vector3 u_vec,
                   PositionFuncT const& position_func,
                   PoseFuncT const& pose_func) : m_position_func(position_func),
                                                 m_pose_func(pose_func) {

      VW_ASSERT(int(line_times.size()) == number_of_lines,
                ArgumentErr() << "LinescanModel: number of line integration times does not match the number of scanlines.\n");

      // Intrinsics
      m_number_of_lines = number_of_lines;
      m_samples_per_line = samples_per_line;
      m_sample_offset = sample_offset;
      m_focal_length = focal_length;
      m_along_scan_pixel_size = along_scan_pixel_size;
      m_across_scan_pixel_size = across_scan_pixel_size;

      m_line_times = line_times;

      m_pointing_vec = normalize(pointing_vec);
      m_u_vec = normalize(u_vec);
    }

    /// This version of the constructor assumes that the line
    /// integration time is consistent throughout the image.
    LinescanModel( int number_of_lines,
                   int samples_per_line,
                   int sample_offset,
                   double focal_length,
                   double along_scan_pixel_size,
                   double across_scan_pixel_size,
                   double line_integration_time,
                   Vector3 pointing_vec,
                   Vector3 u_vec,
                   PositionFuncT const& position_func,
                   PoseFuncT const& pose_func) : m_position_func(position_func),
                                                 m_pose_func(pose_func) {

      // Intrinsics
      m_number_of_lines = number_of_lines;
      m_samples_per_line = samples_per_line;
      m_sample_offset = sample_offset;
      m_focal_length = focal_length;
      m_along_scan_pixel_size = along_scan_pixel_size;
      m_across_scan_pixel_size = across_scan_pixel_size;

      m_line_times.resize(number_of_lines);
      double sum = 0;
      for (int i = 0; i < number_of_lines; ++i) {
        m_line_times[i] = sum;
        sum += line_integration_time;
      }

      m_pointing_vec = normalize(pointing_vec);
      m_u_vec = normalize(u_vec);
    }

    virtual ~LinescanModel() {}
    virtual std::string type() const { return "Linescan"; }

    //------------------------------------------------------------------
    // Interface
    //------------------------------------------------------------------
    virtual Vector2 point_to_pixel(Vector3 const& /*point*/) const {
      vw_throw( vw::NoImplErr() << "LinescanModel::point_to_pixel is not yet implemented." );
      return Vector2(); // never reached
    }

    /// Given a pixel in image coordinates, what is the pointing
    /// vector in 3-space if you apply the camera model.
    ///
    /// Important Note: For linear pushbroom sensors, the orientation
    /// of the image is important.  In the Camera module we adopt the
    /// following convention for pushbroom imagers:
    ///
    /// u is the crosstrack (i.e., perspective) direction
    /// v is the downtrack (i.e., orthographic) direction
    virtual Vector3 pixel_to_vector(Vector2 const& pix) const {
      double u = pix[0], v = pix[1];

      // Check to make sure that this is a valid pixel
      if (int(round(v)) < 0 || int(round(v)) >= int(m_line_times.size()))
        vw_throw( PixelToRayErr() << "LinescanModel: requested pixel "
                  << pix << " is not on a valid scanline." );

      // The view_matrix takes vectors from the camera (extrinsic)
      // coordinate system to the world frame
      //
      // The position and veloctiy are not actually needed, since we are
      // purely interested in returning the direction of the ray at this
      // point and not its origin.
      //
      // The v pixel need not be an integer in every case, therefore
      // we need to linearly interpolate line times that fall in
      // between pixels.
      int y = int(floor(pix[1]));
      double normy = pix[1] - y;
      double approx_line_time =
        double( m_line_times[y] + (m_line_times[y+1] - m_line_times[y]) * normy );

      // The viewplane is the [pointing_vec cross u_vec] plane of the
      // camera coordinate system.  Assuming the origin of the
      // coordinate system is at the center of projection, the image
      // plane is at pointing_vec = +f, and the pixel position in
      // camera coordinates is:
      double pixel_pos_u = (u + m_sample_offset) * m_across_scan_pixel_size;
      Vector<double, 3> pixel_direction =
        pixel_pos_u * m_u_vec + m_focal_length * m_pointing_vec;

      // Transform to world coordinates using the rigid rotation
      return normalize(m_pose_func(approx_line_time).rotate(pixel_direction));
    }

    virtual Vector3 camera_center(Vector2 const& pix = Vector2() ) const {
      // Check to make sure that this is a valid pixel
      if (int(round(pix[1])) < 0 ||
          int(round(pix[1])) >= int(m_line_times.size()))
        vw_throw( PixelToRayErr() << "LinescanModel: requested pixel " << pix << " is not on a valid scanline." );

      // The v pixel need not be an integer in every case, therefore
      // we need to linearly interpolate line times that fall in
      // between pixels.
      int y = int(floor(pix[1]));
      double normy = pix[1] - y;
      double approx_line_time = double( m_line_times[y] + (m_line_times[y+1] - m_line_times[y]) * normy );

      return m_position_func(approx_line_time);
    }

    /// Returns the pose (as a quaternion) of the camera for a given
    /// pixel. Pose is the rotation from camera coordinates to world.
    virtual Quaternion<double> camera_pose(Vector2 const& pix) const {
      // Check to make sure that this is a valid pixel
      if (int(round(pix[1])) < 0 || int(round(pix[1])) >= int(m_line_times.size()))
        vw_throw( PixelToRayErr() << "LinescanModel::camera_pose(): requested pixel " << pix << " is not on a valid scanline." );

      // The v pixel need not be an integer in every case, therefore
      // we need to linearly interpolate line times that fall in
      // between pixels.
      int y = int(floor(pix[1]));
      double normy = pix[1] - y;
      double approx_line_time = double( m_line_times[y] + (m_line_times[y+1] - m_line_times[y]) * normy );

      return m_pose_func(approx_line_time);
    }

    //------------------------------------------------------------------
    // Public Methods
    //------------------------------------------------------------------

    // Accessors
    virtual double number_of_lines() const { return m_number_of_lines; }
    virtual double samples_per_line() const { return m_samples_per_line; }
    virtual double sample_offset() const { return m_sample_offset; }
    virtual double focal_length() const { return m_focal_length; }
    virtual double along_scan_pixel_size() const { return m_along_scan_pixel_size; }
    virtual double across_scan_pixel_size() const { return m_across_scan_pixel_size; }
    virtual std::vector<double> line_times() const { return m_line_times; }
    virtual Vector3 camera_position(double t) const { return m_position_func(t); }
    virtual Quaternion<double> camera_pose(double t) const { return m_pose_func(t); }

    virtual void set_number_of_lines(int val) { m_number_of_lines = val; }
    virtual void set_samples_per_line(int val) { m_samples_per_line = val; }
    virtual void set_sample_offset(int val) { m_sample_offset = val; }
    virtual void set_along_scan_pixel_size(double val) { m_along_scan_pixel_size = val; }
    virtual void set_across_scan_pixel_size(double val) {m_across_scan_pixel_size = val; }
    virtual void set_focal_length(double val) {m_focal_length = val; }
    virtual void set_line_times(std::vector<double> val) { m_line_times = val; }
  };

  /// Output stream method for printing a summary of the linear
  /// pushbroom camera model parameters.
  template <class PositionFuncT, class PoseFuncT>
  std::ostream& operator<<( std::ostream& os, LinescanModel<PositionFuncT, PoseFuncT> const& camera_model) {
    os << "\n-------------------- Linescan Camera Model -------------------\n\n";
    os << " Camera center @ origin :   " << camera_model.camera_center(Vector2(0,0)) << "\n";
    os << " Number of Lines        :   " << camera_model.number_of_lines() << "\n";
    os << " Samples per Line       :   " << camera_model.samples_per_line() << "\n";
    os << " Sample Offset          :   " << camera_model.sample_offset() << "\n";
    os << " Focal Length           :   " << camera_model.focal_length() << "\n";
    os << " Across Scan Pixel Size :   " << camera_model.across_scan_pixel_size() << "\n";
    os << " Along Scan Pixel Size  :   " << camera_model.along_scan_pixel_size() << "\n";
    os << "\n------------------------------------------------------------------------\n\n";
    return os;
  }

}}      // namespace vw::camera

#endif  //_VW_CAMERA_LINEARPUSHBROOM_MODEL_H_


text:
"""Mutational ClusterFuzz fuzzer. A pre-built corpus of ipcdump files has
to be uploaded to ClusterFuzz along with this script. As chrome is being
developed, the corpus will become out-of-date and needs to be updated.

This fuzzer will pick some ipcdumps from the corpus, concatenate them with
ipc_message_util and mutate the result with ipc_fuzzer_mutate.
"""

import os
import random
import subprocess
import sys
import utils

FUZZER_NAME_OPTION = '--fuzzer-name=mutate'
IPC_MESSAGE_UTIL_APPLICATION = 'ipc_message_util'
IPCDUMP_MERGE_LIMIT = 50

class MutationalFuzzer:

  def __init__(self):
    self.args = utils.parse_arguments()

    self.ipc_message_util_binary = utils.application_name_for_platform(
        IPC_MESSAGE_UTIL_APPLICATION)
    self.ipc_fuzzer_binary = utils.get_fuzzer_application_name()
    self.ipc_message_util_binary_path = utils.get_application_path(
        self.ipc_message_util_binary)
    self.ipc_fuzzer_binary_path = utils.get_application_path(
        self.ipc_fuzzer_binary)

  def set_corpus(self):
    # Corpus should be set per job as a fuzzer-specific environment variable.
    corpus = os.getenv('IPC_CORPUS_DIR', 'default')
    corpus_directory = os.path.join(self.args.input_dir, corpus)
    if not os.path.exists(corpus_directory):
      sys.exit('Corpus directory "%s" not found.' % corpus_directory)

    entries = os.listdir(corpus_directory)
    entries = [i for i in entries if i.endswith(utils.IPCDUMP_EXTENSION)]
    self.corpus = [os.path.join(corpus_directory, entry) for entry in entries]

  def create_mutated_ipcdump_testcase(self):
    ipcdumps = ','.join(random.sample(self.corpus, IPCDUMP_MERGE_LIMIT))
    tmp_ipcdump_testcase = utils.create_temp_file()
    mutated_ipcdump_testcase = (
        utils.random_ipcdump_testcase_path(self.args.output_dir))

    # Concatenate ipcdumps -> tmp_ipcdump.
    cmd = [
        self.ipc_message_util_binary_path,
        ipcdumps,
        tmp_ipcdump_testcase,
    ]
    if subprocess.call(cmd):
      sys.exit('%s failed.' % self.ipc_message_util_binary)

    # Mutate tmp_ipcdump -> mutated_ipcdump.
    cmd = [
        self.ipc_fuzzer_binary_path,
        FUZZER_NAME_OPTION,
        tmp_ipcdump_testcase,
        mutated_ipcdump_testcase,
    ]
    if subprocess.call(cmd):
      sys.exit('%s failed.' % self.ipc_fuzzer_binary)

    utils.create_flags_file(mutated_ipcdump_testcase)
    os.remove(tmp_ipcdump_testcase)

  def main(self):
    self.set_corpus()
    for _ in range(self.args.no_of_files):
      self.create_mutated_ipcdump_testcase()

    return 0

if __name__ == '__main__':
  fuzzer = MutationalFuzzer()
  sys.exit(fuzzer.main())


text:
<?php

// запрет прямого доступа
defined('_LINDEX') or die('STOP in file ' . __FILE__);

DEFINE('_PLUGIN_NAME', 'Название плагина');
DEFINE('_NO_PLUGIN_NAME', 'Плагин должен иметь название');
DEFINE('_NO_PLUGIN_FILENAME', 'Плагин должен иметь имя файла');
DEFINE('_SITE_PLUGIN', 'Плагин сайта');
DEFINE('_PLUGIN_DETAILS', 'Детали плагина');
DEFINE('_USE_THIS_PLUGIN_FILE', 'Используемый файл');
DEFINE('_PLUGIN_ORDER', 'Номер по порядку');
DEFINE('_NO_PLUGIN_PARAMS', 'Параметры отсутствуют');
DEFINE('_NEW_PLUGINS_IN_THE_END', 'Новые объекты по умолчанию располагаются в конце. Порядок расположения может быть изменен только после сохранения этого объекта.');
DEFINE('_CHOOSE_PLUGIN_FOR', 'Выберите плагин для');
DEFINE('_COM_PLUGINS_APPLY', 'Все изменения плагина %s успешно сохранены');
DEFINE('_COM_PLUGINS_NON_EDIT', 'редактирвуется другим администратором');
DEFINE('_COM_PLUGINS_NON_REORDER', 'Порядок расположения этого плагина не может быть изменен');


text:
namespace HttpContrib
{
	using System;
	using System.Reflection;
	using System.Threading;
	using System.Windows;
	using System.Windows.Threading;

	/// <summary>
	/// Enables easy marshalling of code to the UI thread.
	/// </summary>
	/// <remarks>
	/// http://caliburnmicro.codeplex.com
	/// </remarks>
	public partial class Execute
	{
		/// <summary>
		/// Initializes the framework using the current dispatcher.
		/// </summary>
		public static void InitializeWithDispatcher()
		{
#if SILVERLIGHT
			var dispatcher = Deployment.Current.Dispatcher;

			executor = action =>
			{
				if (dispatcher.CheckAccess())
					action();
				else
				{
					var waitHandle = new ManualResetEvent(false);
					Exception exception = null;
					dispatcher.BeginInvoke(() =>
					{
						try
						{
							action();
						}
						catch (Exception ex)
						{
							exception = ex;
						}
						waitHandle.Set();
					});
					waitHandle.WaitOne();
					if (exception != null)
						throw new TargetInvocationException("An error occurred while dispatching a call to the UI Thread", exception);
				}
			};
#else
			var dispatcher = Dispatcher.CurrentDispatcher;

			executor = action =>
			{
				if (dispatcher.CheckAccess())
					action();
				else dispatcher.Invoke(action);
			};
#endif

		}
	}
}