text:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>Using the GNU Compiler Collection (GCC): Option Summary</title>

<meta name="description" content="Using the GNU Compiler Collection (GCC): Option Summary">
<meta name="keywords" content="Using the GNU Compiler Collection (GCC): Option Summary">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Option-Index.html#Option-Index" rel="index" title="Option Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Invoking-GCC.html#Invoking-GCC" rel="up" title="Invoking GCC">
<link href="Overall-Options.html#Overall-Options" rel="next" title="Overall Options">
<link href="Invoking-GCC.html#Invoking-GCC" rel="prev" title="Invoking GCC">

Next: Overall Options, Up: Invoking GCC   [Contents][Index]

3.1 Option Summary

Here is a summary of all the options, grouped by type.  Explanations are
in the following sections.

Overall Options

See Options Controlling the Kind of Output.

-c  -S  -E  -o <var>file</var>  -no-canonical-prefixes
-pipe  -pass-exit-codes
-x <var>language</var>  -v  -###  --help[=<var>class</var>[,…]]  --target-help
--version -wrapper @<var>file</var> -fplugin=<var>file</var> -fplugin-arg-<var>name</var>=<var>arg</var>
-fdump-ada-spec[-slim] -fada-spec-parent=<var>unit</var> -fdump-go-spec=<var>file</var>

C Language Options

See Options Controlling C Dialect.

-ansi  -std=<var>standard</var>  -fgnu89-inline
-aux-info <var>filename</var> -fallow-parameterless-variadic-functions
-fno-asm  -fno-builtin  -fno-builtin-<var>function</var>
-fhosted  -ffreestanding -fopenmp -fopenmp-simd -fms-extensions
-fplan9-extensions -trigraphs  -traditional  -traditional-cpp
-fallow-single-precision  -fcond-mismatch -flax-vector-conversions
-fsigned-bitfields  -fsigned-char
-funsigned-bitfields  -funsigned-char

C++ Language Options

See Options Controlling C++ Dialect.

-fabi-version=<var>n</var>  -fno-access-control  -fcheck-new
-fconstexpr-depth=<var>n</var>  -ffriend-injection
-fno-elide-constructors
-fno-enforce-eh-specs
-ffor-scope  -fno-for-scope  -fno-gnu-keywords
-fno-implicit-templates
-fno-implicit-inline-templates
-fno-implement-inlines  -fms-extensions
-fno-nonansi-builtins  -fnothrow-opt  -fno-operator-names
-fno-optional-diags  -fpermissive
-fno-pretty-templates
-frepo  -fno-rtti  -fstats  -ftemplate-backtrace-limit=<var>n</var>
-ftemplate-depth=<var>n</var>
-fno-threadsafe-statics -fuse-cxa-atexit  -fno-weak  -nostdinc++
-fvisibility-inlines-hidden
-fvtable-verify=<var>std|preinit|none</var>
-fvtv-counts -fvtv-debug
-fvisibility-ms-compat
-fext-numeric-literals
-Wabi  -Wconversion-null  -Wctor-dtor-privacy
-Wdelete-non-virtual-dtor -Wliteral-suffix -Wnarrowing
-Wnoexcept -Wnon-virtual-dtor  -Wreorder
-Weffc++  -Wstrict-null-sentinel
-Wno-non-template-friend  -Wold-style-cast
-Woverloaded-virtual  -Wno-pmf-conversions
-Wsign-promo

Objective-C and Objective-C++ Language Options

See Options Controlling
Objective-C and Objective-C++ Dialects.

-fconstant-string-class=<var>class-name</var>
-fgnu-runtime  -fnext-runtime
-fno-nil-receivers
-fobjc-abi-version=<var>n</var>
-fobjc-call-cxx-cdtors
-fobjc-direct-dispatch
-fobjc-exceptions
-fobjc-gc
-fobjc-nilcheck
-fobjc-std=objc1
-freplace-objc-classes
-fzero-link
-gen-decls
-Wassign-intercept
-Wno-protocol  -Wselector
-Wstrict-selector-match
-Wundeclared-selector

Language Independent Options

See Options to Control Diagnostic Messages Formatting.

-fmessage-length=<var>n</var>
-fdiagnostics-show-location=[once|every-line]
-fdiagnostics-color=[auto|never|always]
-fno-diagnostics-show-option -fno-diagnostics-show-caret

Warning Options

See Options to Request or Suppress Warnings.

-fsyntax-only  -fmax-errors=<var>n</var>  -Wpedantic
-pedantic-errors
-w  -Wextra  -Wall  -Waddress  -Waggregate-return
-Waggressive-loop-optimizations -Warray-bounds
-Wno-attributes -Wno-builtin-macro-redefined
-Wc++-compat -Wc++11-compat -Wcast-align  -Wcast-qual
-Wchar-subscripts -Wclobbered  -Wcomment -Wconditionally-supported
-Wconversion -Wcoverage-mismatch -Wdate-time -Wdelete-incomplete -Wno-cpp
-Wno-deprecated -Wno-deprecated-declarations -Wdisabled-optimization
-Wno-div-by-zero -Wdouble-promotion -Wempty-body  -Wenum-compare
-Wno-endif-labels -Werror  -Werror=*
-Wfatal-errors  -Wfloat-equal  -Wformat  -Wformat=2
-Wno-format-contains-nul -Wno-format-extra-args -Wformat-nonliteral
-Wformat-security  -Wformat-y2k
-Wframe-larger-than=<var>len</var> -Wno-free-nonheap-object -Wjump-misses-init
-Wignored-qualifiers
-Wimplicit  -Wimplicit-function-declaration  -Wimplicit-int
-Winit-self  -Winline -Wmaybe-uninitialized
-Wno-int-to-pointer-cast -Wno-invalid-offsetof
-Winvalid-pch -Wlarger-than=<var>len</var>  -Wunsafe-loop-optimizations
-Wlogical-op -Wlong-long
-Wmain -Wmaybe-uninitialized -Wmissing-braces  -Wmissing-field-initializers
-Wmissing-include-dirs
-Wno-multichar  -Wnonnull  -Wno-overflow -Wopenmp-simd
-Woverlength-strings  -Wpacked  -Wpacked-bitfield-compat  -Wpadded
-Wparentheses  -Wpedantic-ms-format -Wno-pedantic-ms-format
-Wpointer-arith  -Wno-pointer-to-int-cast
-Wredundant-decls  -Wno-return-local-addr
-Wreturn-type  -Wsequence-point  -Wshadow
-Wsign-compare  -Wsign-conversion -Wfloat-conversion
-Wsizeof-pointer-memaccess
-Wstack-protector -Wstack-usage=<var>len</var> -Wstrict-aliasing
-Wstrict-aliasing=n  -Wstrict-overflow -Wstrict-overflow=<var>n</var>
-Wsuggest-attribute=[pure|const|noreturn|format]
-Wmissing-format-attribute
-Wswitch  -Wswitch-default  -Wswitch-enum -Wsync-nand
-Wsystem-headers  -Wtrampolines  -Wtrigraphs  -Wtype-limits  -Wundef
-Wuninitialized  -Wunknown-pragmas  -Wno-pragmas
-Wunsuffixed-float-constants  -Wunused  -Wunused-function
-Wunused-label  -Wunused-local-typedefs -Wunused-parameter
-Wno-unused-result -Wunused-value  -Wunused-variable
-Wunused-but-set-parameter -Wunused-but-set-variable
-Wuseless-cast -Wvariadic-macros -Wvector-operation-performance
-Wvla -Wvolatile-register-var  -Wwrite-strings -Wzero-as-null-pointer-constant

C and Objective-C-only Warning Options

-Wbad-function-cast  -Wmissing-declarations
-Wmissing-parameter-type  -Wmissing-prototypes  -Wnested-externs
-Wold-style-declaration  -Wold-style-definition
-Wstrict-prototypes  -Wtraditional  -Wtraditional-conversion
-Wdeclaration-after-statement -Wpointer-sign

Debugging Options

See Options for Debugging Your Program or GCC.

-d<var>letters</var>  -dumpspecs  -dumpmachine  -dumpversion
-fsanitize=<var>style</var>
-fdbg-cnt-list -fdbg-cnt=<var>counter-value-list</var>
-fdisable-ipa-<var>pass_name</var>
-fdisable-rtl-<var>pass_name</var>
-fdisable-rtl-<var>pass-name</var>=<var>range-list</var>
-fdisable-tree-<var>pass_name</var>
-fdisable-tree-<var>pass-name</var>=<var>range-list</var>
-fdump-noaddr -fdump-unnumbered -fdump-unnumbered-links
-fdump-translation-unit[-<var>n</var>]
-fdump-class-hierarchy[-<var>n</var>]
-fdump-ipa-all -fdump-ipa-cgraph -fdump-ipa-inline
-fdump-passes
-fdump-statistics
-fdump-tree-all
-fdump-tree-original[-<var>n</var>]
-fdump-tree-optimized[-<var>n</var>]
-fdump-tree-cfg -fdump-tree-alias
-fdump-tree-ch
-fdump-tree-ssa[-<var>n</var>] -fdump-tree-pre[-<var>n</var>]
-fdump-tree-ccp[-<var>n</var>] -fdump-tree-dce[-<var>n</var>]
-fdump-tree-gimple[-raw]
-fdump-tree-dom[-<var>n</var>]
-fdump-tree-dse[-<var>n</var>]
-fdump-tree-phiprop[-<var>n</var>]
-fdump-tree-phiopt[-<var>n</var>]
-fdump-tree-forwprop[-<var>n</var>]
-fdump-tree-copyrename[-<var>n</var>]
-fdump-tree-nrv -fdump-tree-vect
-fdump-tree-sink
-fdump-tree-sra[-<var>n</var>]
-fdump-tree-forwprop[-<var>n</var>]
-fdump-tree-fre[-<var>n</var>]
-fdump-tree-vtable-verify
-fdump-tree-vrp[-<var>n</var>]
-fdump-tree-storeccp[-<var>n</var>]
-fdump-final-insns=<var>file</var>
-fcompare-debug[=<var>opts</var>]  -fcompare-debug-second
-feliminate-dwarf2-dups -fno-eliminate-unused-debug-types
-feliminate-unused-debug-symbols -femit-class-debug-always
-fenable-<var>kind</var>-<var>pass</var>
-fenable-<var>kind</var>-<var>pass</var>=<var>range-list</var>
-fdebug-types-section -fmem-report-wpa
-fmem-report -fpre-ipa-mem-report -fpost-ipa-mem-report -fprofile-arcs
-fopt-info
-fopt-info-<var>options</var>[=<var>file</var>]
-frandom-seed=<var>string</var> -fsched-verbose=<var>n</var>
-fsel-sched-verbose -fsel-sched-dump-cfg -fsel-sched-pipelining-verbose
-fstack-usage  -ftest-coverage  -ftime-report -fvar-tracking
-fvar-tracking-assignments  -fvar-tracking-assignments-toggle
-g  -g<var>level</var>  -gtoggle  -gcoff  -gdwarf-<var>version</var>
-ggdb  -grecord-gcc-switches  -gno-record-gcc-switches
-gstabs  -gstabs+  -gstrict-dwarf  -gno-strict-dwarf
-gvms  -gxcoff  -gxcoff+
-fno-merge-debug-strings -fno-dwarf2-cfi-asm
-fdebug-prefix-map=<var>old</var>=<var>new</var>
-femit-struct-debug-baseonly -femit-struct-debug-reduced
-femit-struct-debug-detailed[=<var>spec-list</var>]
-p  -pg  -print-file-name=<var>library</var>  -print-libgcc-file-name
-print-multi-directory  -print-multi-lib  -print-multi-os-directory
-print-prog-name=<var>program</var>  -print-search-dirs  -Q
-print-sysroot -print-sysroot-headers-suffix
-save-temps -save-temps=cwd -save-temps=obj -time[=<var>file</var>]

Optimization Options

See Options that Control Optimization.

-faggressive-loop-optimizations -falign-functions[=<var>n</var>]
-falign-jumps[=<var>n</var>]
-falign-labels[=<var>n</var>] -falign-loops[=<var>n</var>]
-fassociative-math -fauto-inc-dec -fbranch-probabilities
-fbranch-target-load-optimize -fbranch-target-load-optimize2
-fbtr-bb-exclusive -fcaller-saves
-fcheck-data-deps -fcombine-stack-adjustments -fconserve-stack
-fcompare-elim -fcprop-registers -fcrossjumping
-fcse-follow-jumps -fcse-skip-blocks -fcx-fortran-rules
-fcx-limited-range
-fdata-sections -fdce -fdelayed-branch
-fdelete-null-pointer-checks -fdevirtualize -fdevirtualize-speculatively -fdse
-fearly-inlining -fipa-sra -fexpensive-optimizations -ffat-lto-objects
-ffast-math -ffinite-math-only -ffloat-store -fexcess-precision=<var>style</var>
-fforward-propagate -ffp-contract=<var>style</var> -ffunction-sections
-fgcse -fgcse-after-reload -fgcse-las -fgcse-lm -fgraphite-identity
-fgcse-sm -fhoist-adjacent-loads -fif-conversion
-fif-conversion2 -findirect-inlining
-finline-functions -finline-functions-called-once -finline-limit=<var>n</var>
-finline-small-functions -fipa-cp -fipa-cp-clone
-fipa-pta -fipa-profile -fipa-pure-const -fipa-reference
-fira-algorithm=<var>algorithm</var>
-fira-region=<var>region</var> -fira-hoist-pressure
-fira-loop-pressure -fno-ira-share-save-slots
-fno-ira-share-spill-slots -fira-verbose=<var>n</var>
-fisolate-erroneous-paths-dereference -fisolate-erroneous-paths-attribute
-fivopts -fkeep-inline-functions -fkeep-static-consts -flive-range-shrinkage
-floop-block -floop-interchange -floop-strip-mine -floop-nest-optimize
-floop-parallelize-all -flto -flto-compression-level
-flto-partition=<var>alg</var> -flto-report -flto-report-wpa -fmerge-all-constants
-fmerge-constants -fmodulo-sched -fmodulo-sched-allow-regmoves
-fmove-loop-invariants -fno-branch-count-reg
-fno-defer-pop -fno-function-cse -fno-guess-branch-probability
-fno-inline -fno-math-errno -fno-peephole -fno-peephole2
-fno-sched-interblock -fno-sched-spec -fno-signed-zeros
-fno-toplevel-reorder -fno-trapping-math -fno-zero-initialized-in-bss
-fomit-frame-pointer -foptimize-sibling-calls
-fpartial-inlining -fpeel-loops -fpredictive-commoning
-fprefetch-loop-arrays -fprofile-report
-fprofile-correction -fprofile-dir=<var>path</var> -fprofile-generate
-fprofile-generate=<var>path</var>
-fprofile-use -fprofile-use=<var>path</var> -fprofile-values -fprofile-reorder-functions
-freciprocal-math -free -frename-registers -freorder-blocks
-freorder-blocks-and-partition -freorder-functions
-frerun-cse-after-loop -freschedule-modulo-scheduled-loops
-frounding-math -fsched2-use-superblocks -fsched-pressure
-fsched-spec-load -fsched-spec-load-dangerous
-fsched-stalled-insns-dep[=<var>n</var>] -fsched-stalled-insns[=<var>n</var>]
-fsched-group-heuristic -fsched-critical-path-heuristic
-fsched-spec-insn-heuristic -fsched-rank-heuristic
-fsched-last-insn-heuristic -fsched-dep-count-heuristic
-fschedule-insns -fschedule-insns2 -fsection-anchors
-fselective-scheduling -fselective-scheduling2
-fsel-sched-pipelining -fsel-sched-pipelining-outer-loops
-fshrink-wrap -fsignaling-nans -fsingle-precision-constant
-fsplit-ivs-in-unroller -fsplit-wide-types -fstack-protector
-fstack-protector-all -fstack-protector-strong -fstrict-aliasing
-fstrict-overflow -fthread-jumps -ftracer -ftree-bit-ccp
-ftree-builtin-call-dce -ftree-ccp -ftree-ch
-ftree-coalesce-inline-vars -ftree-coalesce-vars -ftree-copy-prop
-ftree-copyrename -ftree-dce -ftree-dominator-opts -ftree-dse
-ftree-forwprop -ftree-fre -ftree-loop-if-convert
-ftree-loop-if-convert-stores -ftree-loop-im
-ftree-phiprop -ftree-loop-distribution -ftree-loop-distribute-patterns
-ftree-loop-ivcanon -ftree-loop-linear -ftree-loop-optimize
-ftree-loop-vectorize
-ftree-parallelize-loops=<var>n</var> -ftree-pre -ftree-partial-pre -ftree-pta
-ftree-reassoc -ftree-sink -ftree-slsr -ftree-sra
-ftree-switch-conversion -ftree-tail-merge -ftree-ter
-ftree-vectorize -ftree-vrp
-funit-at-a-time -funroll-all-loops -funroll-loops
-funsafe-loop-optimizations -funsafe-math-optimizations -funswitch-loops
-fvariable-expansion-in-unroller -fvect-cost-model -fvpt -fweb
-fwhole-program -fwpa -fuse-ld=<var>linker</var> -fuse-linker-plugin
--param <var>name</var>=<var>value</var>
-O  -O0  -O1  -O2  -O3  -Os -Ofast -Og

Preprocessor Options

See Options Controlling the Preprocessor.

-A<var>question</var>=<var>answer</var>
-A-<var>question</var>[=<var>answer</var>]
-C  -dD  -dI  -dM  -dN
-D<var>macro</var>[=<var>defn</var>]  -E  -H
-idirafter <var>dir</var>
-include <var>file</var>  -imacros <var>file</var>
-iprefix <var>file</var>  -iwithprefix <var>dir</var>
-iwithprefixbefore <var>dir</var>  -isystem <var>dir</var>
-imultilib <var>dir</var> -isysroot <var>dir</var>
-M  -MM  -MF  -MG  -MP  -MQ  -MT  -nostdinc
-P  -fdebug-cpp -ftrack-macro-expansion -fworking-directory
-remap -trigraphs  -undef  -U<var>macro</var>
-Wp,<var>option</var> -Xpreprocessor <var>option</var> -no-integrated-cpp

Assembler Option

See Passing Options to the Assembler.

-Wa,<var>option</var>  -Xassembler <var>option</var>

Linker Options

See Options for Linking.

<var>object-file-name</var>  -l<var>library</var>
-nostartfiles  -nodefaultlibs  -nostdlib -pie -rdynamic
-s  -static -static-libgcc -static-libstdc++
-static-libasan -static-libtsan -static-liblsan -static-libubsan
-shared -shared-libgcc  -symbolic
-T <var>script</var>  -Wl,<var>option</var>  -Xlinker <var>option</var>
-u <var>symbol</var>

Directory Options

See Options for Directory Search.

-B<var>prefix</var> -I<var>dir</var> -iplugindir=<var>dir</var>
-iquote<var>dir</var> -L<var>dir</var> -specs=<var>file</var> -I-
--sysroot=<var>dir</var> --no-sysroot-suffix

Machine Dependent Options

See Hardware Models and Configurations.

AArch64 Options

-mabi=<var>name</var>  -mbig-endian  -mlittle-endian
-mgeneral-regs-only
-mcmodel=tiny  -mcmodel=small  -mcmodel=large
-mstrict-align
-momit-leaf-frame-pointer  -mno-omit-leaf-frame-pointer
-mtls-dialect=desc  -mtls-dialect=traditional
-mfix-cortex-a53-835769  -mno-fix-cortex-a53-835769
-mfix-cortex-a53-843419  -mno-fix-cortex-a53-843419
-march=<var>name</var>  -mcpu=<var>name</var>  -mtune=<var>name</var>

Adapteva Epiphany Options

-mhalf-reg-file -mprefer-short-insn-regs
-mbranch-cost=<var>num</var> -mcmove -mnops=<var>num</var> -msoft-cmpsf
-msplit-lohi -mpost-inc -mpost-modify -mstack-offset=<var>num</var>
-mround-nearest -mlong-calls -mshort-calls -msmall16
-mfp-mode=<var>mode</var> -mvect-double -max-vect-align=<var>num</var>
-msplit-vecmove-early -m1reg-<var>reg</var>

ARC Options

-mbarrel-shifter
-mcpu=<var>cpu</var> -mA6 -mARC600 -mA7 -mARC700
-mdpfp -mdpfp-compact -mdpfp-fast -mno-dpfp-lrsr
-mea -mno-mpy -mmul32x16 -mmul64
-mnorm -mspfp -mspfp-compact -mspfp-fast -msimd -msoft-float -mswap
-mcrc -mdsp-packa -mdvbf -mlock -mmac-d16 -mmac-24 -mrtsc -mswape
-mtelephony -mxy -misize -mannotate-align -marclinux -marclinux_prof
-mepilogue-cfi -mlong-calls -mmedium-calls -msdata
-mucb-mcount -mvolatile-cache
-malign-call -mauto-modify-reg -mbbit-peephole -mno-brcc
-mcase-vector-pcrel -mcompact-casesi -mno-cond-exec -mearly-cbranchsi
-mexpand-adddi -mindexed-loads -mlra -mlra-priority-none
-mlra-priority-compact mlra-priority-noncompact -mno-millicode
-mmixed-code -mq-class -mRcq -mRcw -msize-level=<var>level</var>
-mtune=<var>cpu</var> -mmultcost=<var>num</var> -munalign-prob-threshold=<var>probability</var>

ARM Options

-mapcs-frame  -mno-apcs-frame
-mabi=<var>name</var>
-mapcs-stack-check  -mno-apcs-stack-check
-mapcs-float  -mno-apcs-float
-mapcs-reentrant  -mno-apcs-reentrant
-msched-prolog  -mno-sched-prolog
-mlittle-endian  -mbig-endian  -mwords-little-endian
-mfloat-abi=<var>name</var>
-mfp16-format=<var>name</var>
-mthumb-interwork  -mno-thumb-interwork
-mcpu=<var>name</var>  -march=<var>name</var>  -mfpu=<var>name</var>
-mstructure-size-boundary=<var>n</var>
-mabort-on-noreturn
-mlong-calls  -mno-long-calls
-msingle-pic-base  -mno-single-pic-base
-mpic-register=<var>reg</var>
-mnop-fun-dllimport
-mpoke-function-name
-mthumb  -marm
-mtpcs-frame  -mtpcs-leaf-frame
-mcaller-super-interworking  -mcallee-super-interworking
-mtp=<var>name</var> -mtls-dialect=<var>dialect</var>
-mword-relocations
-mfix-cortex-m3-ldrd
-munaligned-access
-mneon-for-64bits
-mslow-flash-data
-mrestrict-it

AVR Options

-mmcu=<var>mcu</var> -maccumulate-args -mbranch-cost=<var>cost</var>
-mcall-prologues -mint8 -mno-interrupts -mrelax
-mstrict-X -mtiny-stack -Waddr-space-convert

Blackfin Options

-mcpu=<var>cpu</var>[-<var>sirevision</var>]
-msim -momit-leaf-frame-pointer  -mno-omit-leaf-frame-pointer
-mspecld-anomaly  -mno-specld-anomaly  -mcsync-anomaly  -mno-csync-anomaly
-mlow-64k -mno-low64k  -mstack-check-l1  -mid-shared-library
-mno-id-shared-library  -mshared-library-id=<var>n</var>
-mleaf-id-shared-library  -mno-leaf-id-shared-library
-msep-data  -mno-sep-data  -mlong-calls  -mno-long-calls
-mfast-fp -minline-plt -mmulticore  -mcorea  -mcoreb  -msdram
-micplb

C6X Options

-mbig-endian  -mlittle-endian -march=<var>cpu</var>
-msim -msdata=<var>sdata-type</var>

CRIS Options

-mcpu=<var>cpu</var>  -march=<var>cpu</var>  -mtune=<var>cpu</var>
-mmax-stack-frame=<var>n</var>  -melinux-stacksize=<var>n</var>
-metrax4  -metrax100  -mpdebug  -mcc-init  -mno-side-effects
-mstack-align  -mdata-align  -mconst-align
-m32-bit  -m16-bit  -m8-bit  -mno-prologue-epilogue  -mno-gotplt
-melf  -maout  -melinux  -mlinux  -sim  -sim2
-mmul-bug-workaround  -mno-mul-bug-workaround

CR16 Options

-mmac
-mcr16cplus -mcr16c
-msim -mint32 -mbit-ops
-mdata-model=<var>model</var>

Darwin Options

-all_load  -allowable_client  -arch  -arch_errors_fatal
-arch_only  -bind_at_load  -bundle  -bundle_loader
-client_name  -compatibility_version  -current_version
-dead_strip
-dependency-file  -dylib_file  -dylinker_install_name
-dynamic  -dynamiclib  -exported_symbols_list
-filelist  -flat_namespace  -force_cpusubtype_ALL
-force_flat_namespace  -headerpad_max_install_names
-iframework
-image_base  -init  -install_name  -keep_private_externs
-multi_module  -multiply_defined  -multiply_defined_unused
-noall_load   -no_dead_strip_inits_and_terms
-nofixprebinding -nomultidefs  -noprebind  -noseglinkedit
-pagezero_size  -prebind  -prebind_all_twolevel_modules
-private_bundle  -read_only_relocs  -sectalign
-sectobjectsymbols  -whyload  -seg1addr
-sectcreate  -sectobjectsymbols  -sectorder
-segaddr -segs_read_only_addr -segs_read_write_addr
-seg_addr_table  -seg_addr_table_filename  -seglinkedit
-segprot  -segs_read_only_addr  -segs_read_write_addr
-single_module  -static  -sub_library  -sub_umbrella
-twolevel_namespace  -umbrella  -undefined
-unexported_symbols_list  -weak_reference_mismatches
-whatsloaded -F -gused -gfull -mmacosx-version-min=<var>version</var>
-mkernel -mone-byte-bool

DEC Alpha Options

-mno-fp-regs  -msoft-float
-mieee  -mieee-with-inexact  -mieee-conformant
-mfp-trap-mode=<var>mode</var>  -mfp-rounding-mode=<var>mode</var>
-mtrap-precision=<var>mode</var>  -mbuild-constants
-mcpu=<var>cpu-type</var>  -mtune=<var>cpu-type</var>
-mbwx  -mmax  -mfix  -mcix
-mfloat-vax  -mfloat-ieee
-mexplicit-relocs  -msmall-data  -mlarge-data
-msmall-text  -mlarge-text
-mmemory-latency=<var>time</var>

FR30 Options

-msmall-model -mno-lsim

FRV Options

-mgpr-32  -mgpr-64  -mfpr-32  -mfpr-64
-mhard-float  -msoft-float
-malloc-cc  -mfixed-cc  -mdword  -mno-dword
-mdouble  -mno-double
-mmedia  -mno-media  -mmuladd  -mno-muladd
-mfdpic  -minline-plt -mgprel-ro  -multilib-library-pic
-mlinked-fp  -mlong-calls  -malign-labels
-mlibrary-pic  -macc-4  -macc-8
-mpack  -mno-pack  -mno-eflags  -mcond-move  -mno-cond-move
-moptimize-membar -mno-optimize-membar
-mscc  -mno-scc  -mcond-exec  -mno-cond-exec
-mvliw-branch  -mno-vliw-branch
-mmulti-cond-exec  -mno-multi-cond-exec  -mnested-cond-exec
-mno-nested-cond-exec  -mtomcat-stats
-mTLS -mtls
-mcpu=<var>cpu</var>

GNU/Linux Options

-mglibc -muclibc -mbionic -mandroid
-tno-android-cc -tno-android-ld

H8/300 Options

-mrelax  -mh  -ms  -mn  -mexr -mno-exr  -mint32  -malign-300

HPPA Options

-march=<var>architecture-type</var>
-mdisable-fpregs  -mdisable-indexing
-mfast-indirect-calls  -mgas  -mgnu-ld   -mhp-ld
-mfixed-range=<var>register-range</var>
-mjump-in-delay -mlinker-opt -mlong-calls
-mlong-load-store  -mno-disable-fpregs
-mno-disable-indexing  -mno-fast-indirect-calls  -mno-gas
-mno-jump-in-delay  -mno-long-load-store
-mno-portable-runtime  -mno-soft-float
-mno-space-regs  -msoft-float  -mpa-risc-1-0
-mpa-risc-1-1  -mpa-risc-2-0  -mportable-runtime
-mschedule=<var>cpu-type</var>  -mspace-regs  -msio  -mwsio
-munix=<var>unix-std</var>  -nolibdld  -static  -threads

i386 and x86-64 Options

-mtune=<var>cpu-type</var>  -march=<var>cpu-type</var>
-mtune-ctrl=<var>feature-list</var> -mdump-tune-features -mno-default
-mfpmath=<var>unit</var>
-masm=<var>dialect</var>  -mno-fancy-math-387
-mno-fp-ret-in-387  -msoft-float
-mno-wide-multiply  -mrtd  -malign-double
-mpreferred-stack-boundary=<var>num</var>
-mincoming-stack-boundary=<var>num</var>
-mcld -mcx16 -msahf -mmovbe -mcrc32
-mrecip -mrecip=<var>opt</var>
-mvzeroupper -mprefer-avx128
-mmmx  -msse  -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -msse4 -mavx
-mavx2 -mavx512f -mavx512pf -mavx512er -mavx512cd -msha
-maes -mpclmul -mfsgsbase -mrdrnd -mf16c -mfma -mprefetchwt1
-msse4a -m3dnow -mpopcnt -mabm -mbmi -mtbm -mfma4 -mxop -mlzcnt
-mbmi2 -mfxsr -mxsave -mxsaveopt -mrtm -mlwp -mthreads
-mno-align-stringops  -minline-all-stringops
-minline-stringops-dynamically -mstringop-strategy=<var>alg</var>
-mmemcpy-strategy=<var>strategy</var> -mmemset-strategy=<var>strategy</var>
-mpush-args  -maccumulate-outgoing-args  -m128bit-long-double
-m96bit-long-double -mlong-double-64 -mlong-double-80 -mlong-double-128
-mregparm=<var>num</var>  -msseregparm
-mveclibabi=<var>type</var> -mvect8-ret-in-mem
-mpc32 -mpc64 -mpc80 -mstackrealign
-momit-leaf-frame-pointer  -mno-red-zone -mno-tls-direct-seg-refs
-mcmodel=<var>code-model</var> -mabi=<var>name</var> -maddress-mode=<var>mode</var>
-m32 -m64 -mx32 -m16 -mlarge-data-threshold=<var>num</var>
-msse2avx -mfentry -m8bit-idiv
-mavx256-split-unaligned-load -mavx256-split-unaligned-store
-mstack-protector-guard=<var>guard</var>

i386 and x86-64 Windows Options

-mconsole -mcygwin -mno-cygwin -mdll
-mnop-fun-dllimport -mthread
-municode -mwin32 -mwindows -fno-set-stack-executable

IA-64 Options

-mbig-endian  -mlittle-endian  -mgnu-as  -mgnu-ld  -mno-pic
-mvolatile-asm-stop  -mregister-names  -msdata -mno-sdata
-mconstant-gp  -mauto-pic  -mfused-madd
-minline-float-divide-min-latency
-minline-float-divide-max-throughput
-mno-inline-float-divide
-minline-int-divide-min-latency
-minline-int-divide-max-throughput
-mno-inline-int-divide
-minline-sqrt-min-latency -minline-sqrt-max-throughput
-mno-inline-sqrt
-mdwarf2-asm -mearly-stop-bits
-mfixed-range=<var>register-range</var> -mtls-size=<var>tls-size</var>
-mtune=<var>cpu-type</var> -milp32 -mlp64
-msched-br-data-spec -msched-ar-data-spec -msched-control-spec
-msched-br-in-data-spec -msched-ar-in-data-spec -msched-in-control-spec
-msched-spec-ldc -msched-spec-control-ldc
-msched-prefer-non-data-spec-insns -msched-prefer-non-control-spec-insns
-msched-stop-bits-after-every-cycle -msched-count-spec-in-critical-path
-msel-sched-dont-check-control-spec -msched-fp-mem-deps-zero-cost
-msched-max-memory-insns-hard-limit -msched-max-memory-insns=<var>max-insns</var>

LM32 Options

-mbarrel-shift-enabled -mdivide-enabled -mmultiply-enabled
-msign-extend-enabled -muser-enabled

M32R/D Options

-m32r2 -m32rx -m32r
-mdebug
-malign-loops -mno-align-loops
-missue-rate=<var>number</var>
-mbranch-cost=<var>number</var>
-mmodel=<var>code-size-model-type</var>
-msdata=<var>sdata-type</var>
-mno-flush-func -mflush-func=<var>name</var>
-mno-flush-trap -mflush-trap=<var>number</var>
-G <var>num</var>

M32C Options

-mcpu=<var>cpu</var> -msim -memregs=<var>number</var>

M680x0 Options

-march=<var>arch</var>  -mcpu=<var>cpu</var>  -mtune=<var>tune</var>
-m68000  -m68020  -m68020-40  -m68020-60  -m68030  -m68040
-m68060  -mcpu32  -m5200  -m5206e  -m528x  -m5307  -m5407
-mcfv4e  -mbitfield  -mno-bitfield  -mc68000  -mc68020
-mnobitfield  -mrtd  -mno-rtd  -mdiv  -mno-div  -mshort
-mno-short  -mhard-float  -m68881  -msoft-float  -mpcrel
-malign-int  -mstrict-align  -msep-data  -mno-sep-data
-mshared-library-id=n  -mid-shared-library  -mno-id-shared-library
-mxgot -mno-xgot

MCore Options

-mhardlit  -mno-hardlit  -mdiv  -mno-div  -mrelax-immediates
-mno-relax-immediates  -mwide-bitfields  -mno-wide-bitfields
-m4byte-functions  -mno-4byte-functions  -mcallgraph-data
-mno-callgraph-data  -mslow-bytes  -mno-slow-bytes  -mno-lsim
-mlittle-endian  -mbig-endian  -m210  -m340  -mstack-increment

MeP Options

-mabsdiff -mall-opts -maverage -mbased=<var>n</var> -mbitops
-mc=<var>n</var> -mclip -mconfig=<var>name</var> -mcop -mcop32 -mcop64 -mivc2
-mdc -mdiv -meb -mel -mio-volatile -ml -mleadz -mm -mminmax
-mmult -mno-opts -mrepeat -ms -msatur -msdram -msim -msimnovec -mtf
-mtiny=<var>n</var>

MicroBlaze Options

-msoft-float -mhard-float -msmall-divides -mcpu=<var>cpu</var>
-mmemcpy -mxl-soft-mul -mxl-soft-div -mxl-barrel-shift
-mxl-pattern-compare -mxl-stack-check -mxl-gp-opt -mno-clearbss
-mxl-multiply-high -mxl-float-convert -mxl-float-sqrt
-mbig-endian -mlittle-endian -mxl-reorder -mxl-mode-<var>app-model</var>

MIPS Options

-EL  -EB  -march=<var>arch</var>  -mtune=<var>arch</var>
-mips1  -mips2  -mips3  -mips4  -mips32  -mips32r2
-mips64  -mips64r2
-mips16  -mno-mips16  -mflip-mips16
-minterlink-compressed -mno-interlink-compressed
-minterlink-mips16  -mno-interlink-mips16
-mabi=<var>abi</var>  -mabicalls  -mno-abicalls
-mshared  -mno-shared  -mplt  -mno-plt  -mxgot  -mno-xgot
-mgp32  -mgp64  -mfp32  -mfp64  -mhard-float  -msoft-float
-mno-float  -msingle-float  -mdouble-float
-mabs=<var>mode</var>  -mnan=<var>encoding</var>
-mdsp  -mno-dsp  -mdspr2  -mno-dspr2
-mmcu -mmno-mcu
-meva -mno-eva
-mvirt -mno-virt
-mmicromips -mno-micromips
-mfpu=<var>fpu-type</var>
-msmartmips  -mno-smartmips
-mpaired-single  -mno-paired-single  -mdmx  -mno-mdmx
-mips3d  -mno-mips3d  -mmt  -mno-mt  -mllsc  -mno-llsc
-mlong64  -mlong32  -msym32  -mno-sym32
-G<var>num</var>  -mlocal-sdata  -mno-local-sdata
-mextern-sdata  -mno-extern-sdata  -mgpopt  -mno-gopt
-membedded-data  -mno-embedded-data
-muninit-const-in-rodata  -mno-uninit-const-in-rodata
-mcode-readable=<var>setting</var>
-msplit-addresses  -mno-split-addresses
-mexplicit-relocs  -mno-explicit-relocs
-mcheck-zero-division  -mno-check-zero-division
-mdivide-traps  -mdivide-breaks
-mmemcpy  -mno-memcpy  -mlong-calls  -mno-long-calls
-mmad -mno-mad -mimadd -mno-imadd -mfused-madd  -mno-fused-madd  -nocpp
-mfix-24k -mno-fix-24k
-mfix-r4000  -mno-fix-r4000  -mfix-r4400  -mno-fix-r4400
-mfix-r10000 -mno-fix-r10000  -mfix-rm7000 -mno-fix-rm7000
-mfix-vr4120  -mno-fix-vr4120
-mfix-vr4130  -mno-fix-vr4130  -mfix-sb1  -mno-fix-sb1
-mflush-func=<var>func</var>  -mno-flush-func
-mbranch-cost=<var>num</var>  -mbranch-likely  -mno-branch-likely
-mfp-exceptions -mno-fp-exceptions
-mvr4130-align -mno-vr4130-align -msynci -mno-synci
-mrelax-pic-calls -mno-relax-pic-calls -mmcount-ra-address

MMIX Options

-mlibfuncs  -mno-libfuncs  -mepsilon  -mno-epsilon  -mabi=gnu
-mabi=mmixware  -mzero-extend  -mknuthdiv  -mtoplevel-symbols
-melf  -mbranch-predict  -mno-branch-predict  -mbase-addresses
-mno-base-addresses  -msingle-exit  -mno-single-exit

MN10300 Options

-mmult-bug  -mno-mult-bug
-mno-am33 -mam33 -mam33-2 -mam34
-mtune=<var>cpu-type</var>
-mreturn-pointer-on-d0
-mno-crt0  -mrelax -mliw -msetlb

Moxie Options

-meb -mel -mno-crt0

MSP430 Options

-msim -masm-hex -mmcu= -mcpu= -mlarge -msmall -mrelax
-mhwmult= -minrt

NDS32 Options

-mbig-endian -mlittle-endian
-mreduced-regs -mfull-regs
-mcmov -mno-cmov
-mperf-ext -mno-perf-ext
-mv3push -mno-v3push
-m16bit -mno-16bit
-mgp-direct -mno-gp-direct
-misr-vector-size=<var>num</var>
-mcache-block-size=<var>num</var>
-march=<var>arch</var>
-mforce-fp-as-gp -mforbid-fp-as-gp
-mex9 -mctor-dtor -mrelax

Nios II Options

-G <var>num</var> -mgpopt -mno-gpopt -mel -meb
-mno-bypass-cache -mbypass-cache
-mno-cache-volatile -mcache-volatile
-mno-fast-sw-div -mfast-sw-div
-mhw-mul -mno-hw-mul -mhw-mulx -mno-hw-mulx -mno-hw-div -mhw-div
-mcustom-<var>insn</var>=<var>N</var> -mno-custom-<var>insn</var>
-mcustom-fpu-cfg=<var>name</var>
-mhal -msmallc -msys-crt0=<var>name</var> -msys-lib=<var>name</var>

PDP-11 Options

-mfpu  -msoft-float  -mac0  -mno-ac0  -m40  -m45  -m10
-mbcopy  -mbcopy-builtin  -mint32  -mno-int16
-mint16  -mno-int32  -mfloat32  -mno-float64
-mfloat64  -mno-float32  -mabshi  -mno-abshi
-mbranch-expensive  -mbranch-cheap
-munix-asm  -mdec-asm

picoChip Options

-mae=<var>ae_type</var> -mvliw-lookahead=<var>N</var>
-msymbol-as-address -mno-inefficient-warnings

PowerPC Options
See RS/6000 and PowerPC Options.

RL78 Options

-msim -mmul=none -mmul=g13 -mmul=rl78

RS/6000 and PowerPC Options

-mcpu=<var>cpu-type</var>
-mtune=<var>cpu-type</var>
-mcmodel=<var>code-model</var>
-mpowerpc64
-maltivec  -mno-altivec
-mpowerpc-gpopt  -mno-powerpc-gpopt
-mpowerpc-gfxopt  -mno-powerpc-gfxopt
-mmfcrf  -mno-mfcrf  -mpopcntb  -mno-popcntb -mpopcntd -mno-popcntd
-mfprnd  -mno-fprnd
-mcmpb -mno-cmpb -mmfpgpr -mno-mfpgpr -mhard-dfp -mno-hard-dfp
-mfull-toc   -mminimal-toc  -mno-fp-in-toc  -mno-sum-in-toc
-m64  -m32  -mxl-compat  -mno-xl-compat  -mpe
-malign-power  -malign-natural
-msoft-float  -mhard-float  -mmultiple  -mno-multiple
-msingle-float -mdouble-float -msimple-fpu
-mstring  -mno-string  -mupdate  -mno-update
-mavoid-indexed-addresses  -mno-avoid-indexed-addresses
-mfused-madd  -mno-fused-madd  -mbit-align  -mno-bit-align
-mstrict-align  -mno-strict-align  -mrelocatable
-mno-relocatable  -mrelocatable-lib  -mno-relocatable-lib
-mtoc  -mno-toc  -mlittle  -mlittle-endian  -mbig  -mbig-endian
-mdynamic-no-pic  -maltivec -mswdiv  -msingle-pic-base
-mprioritize-restricted-insns=<var>priority</var>
-msched-costly-dep=<var>dependence_type</var>
-minsert-sched-nops=<var>scheme</var>
-mcall-sysv  -mcall-netbsd
-maix-struct-return  -msvr4-struct-return
-mabi=<var>abi-type</var> -msecure-plt -mbss-plt
-mblock-move-inline-limit=<var>num</var>
-misel -mno-isel
-misel=yes  -misel=no
-mspe -mno-spe
-mspe=yes  -mspe=no
-mpaired
-mgen-cell-microcode -mwarn-cell-microcode
-mvrsave -mno-vrsave
-mmulhw -mno-mulhw
-mdlmzb -mno-dlmzb
-mfloat-gprs=yes  -mfloat-gprs=no -mfloat-gprs=single -mfloat-gprs=double
-mprototype  -mno-prototype
-msim  -mmvme  -mads  -myellowknife  -memb  -msdata
-msdata=<var>opt</var>  -mvxworks  -G <var>num</var>  -pthread
-mrecip -mrecip=<var>opt</var> -mno-recip -mrecip-precision
-mno-recip-precision
-mveclibabi=<var>type</var> -mfriz -mno-friz
-mpointers-to-nested-functions -mno-pointers-to-nested-functions
-msave-toc-indirect -mno-save-toc-indirect
-mpower8-fusion -mno-mpower8-fusion -mpower8-vector -mno-power8-vector
-mcrypto -mno-crypto -mdirect-move -mno-direct-move
-mquad-memory -mno-quad-memory
-mquad-memory-atomic -mno-quad-memory-atomic
-mcompat-align-parm -mno-compat-align-parm

RX Options

-m64bit-doubles  -m32bit-doubles  -fpu  -nofpu
-mcpu=
-mbig-endian-data -mlittle-endian-data
-msmall-data
-msim  -mno-sim
-mas100-syntax -mno-as100-syntax
-mrelax
-mmax-constant-size=
-mint-register=
-mpid
-mno-warn-multiple-fast-interrupts
-msave-acc-in-interrupts

S/390 and zSeries Options

-mtune=<var>cpu-type</var>  -march=<var>cpu-type</var>
-mhard-float  -msoft-float  -mhard-dfp -mno-hard-dfp
-mlong-double-64 -mlong-double-128
-mbackchain  -mno-backchain -mpacked-stack  -mno-packed-stack
-msmall-exec  -mno-small-exec  -mmvcle -mno-mvcle
-m64  -m31  -mdebug  -mno-debug  -mesa  -mzarch
-mtpf-trace -mno-tpf-trace  -mfused-madd  -mno-fused-madd
-mwarn-framesize  -mwarn-dynamicstack  -mstack-size -mstack-guard
-mhotpatch[=<var>halfwords</var>] -mno-hotpatch

Score Options

-meb -mel
-mnhwloop
-muls
-mmac
-mscore5 -mscore5u -mscore7 -mscore7d

SH Options

-m1  -m2  -m2e
-m2a-nofpu -m2a-single-only -m2a-single -m2a
-m3  -m3e
-m4-nofpu  -m4-single-only  -m4-single  -m4
-m4a-nofpu -m4a-single-only -m4a-single -m4a -m4al
-m5-64media  -m5-64media-nofpu
-m5-32media  -m5-32media-nofpu
-m5-compact  -m5-compact-nofpu
-mb  -ml  -mdalign  -mrelax
-mbigtable -mfmovd -mhitachi -mrenesas -mno-renesas -mnomacsave
-mieee -mno-ieee -mbitops  -misize  -minline-ic_invalidate -mpadstruct
-mspace -mprefergot  -musermode -multcost=<var>number</var> -mdiv=<var>strategy</var>
-mdivsi3_libfunc=<var>name</var> -mfixed-range=<var>register-range</var>
-mindexed-addressing -mgettrcost=<var>number</var> -mpt-fixed
-maccumulate-outgoing-args -minvalid-symbols
-matomic-model=<var>atomic-model</var>
-mbranch-cost=<var>num</var> -mzdcbranch -mno-zdcbranch
-mfused-madd -mno-fused-madd -mfsca -mno-fsca -mfsrra -mno-fsrra
-mpretend-cmove -mtas

Solaris 2 Options

-mclear-hwcap -mno-clear-hwcap -mimpure-text  -mno-impure-text
-pthreads -pthread

SPARC Options

-mcpu=<var>cpu-type</var>
-mtune=<var>cpu-type</var>
-mcmodel=<var>code-model</var>
-mmemory-model=<var>mem-model</var>
-m32  -m64  -mapp-regs  -mno-app-regs
-mfaster-structs  -mno-faster-structs  -mflat  -mno-flat
-mfpu  -mno-fpu  -mhard-float  -msoft-float
-mhard-quad-float  -msoft-quad-float
-mstack-bias  -mno-stack-bias
-munaligned-doubles  -mno-unaligned-doubles
-muser-mode  -mno-user-mode
-mv8plus  -mno-v8plus  -mvis  -mno-vis
-mvis2  -mno-vis2  -mvis3  -mno-vis3
-mcbcond -mno-cbcond
-mfmaf  -mno-fmaf  -mpopc  -mno-popc
-mfix-at697f -mfix-ut699

SPU Options

-mwarn-reloc -merror-reloc
-msafe-dma -munsafe-dma
-mbranch-hints
-msmall-mem -mlarge-mem -mstdmain
-mfixed-range=<var>register-range</var>
-mea32 -mea64
-maddress-space-conversion -mno-address-space-conversion
-mcache-size=<var>cache-size</var>
-matomic-updates -mno-atomic-updates

System V Options

-Qy  -Qn  -YP,<var>paths</var>  -Ym,<var>dir</var>

TILE-Gx Options

-mcpu=CPU -m32 -m64 -mbig-endian -mlittle-endian
-mcmodel=<var>code-model</var>

TILEPro Options

-mcpu=<var>cpu</var> -m32

V850 Options

-mlong-calls  -mno-long-calls  -mep  -mno-ep
-mprolog-function  -mno-prolog-function  -mspace
-mtda=<var>n</var>  -msda=<var>n</var>  -mzda=<var>n</var>
-mapp-regs  -mno-app-regs
-mdisable-callt  -mno-disable-callt
-mv850e2v3 -mv850e2 -mv850e1 -mv850es
-mv850e -mv850 -mv850e3v5
-mloop
-mrelax
-mlong-jumps
-msoft-float
-mhard-float
-mgcc-abi
-mrh850-abi
-mbig-switch

VAX Options

-mg  -mgnu  -munix

VMS Options

-mvms-return-codes -mdebug-main=<var>prefix</var> -mmalloc64
-mpointer-size=<var>size</var>

VxWorks Options

-mrtp  -non-static  -Bstatic  -Bdynamic
-Xbind-lazy  -Xbind-now

x86-64 Options
See i386 and x86-64 Options.

Xstormy16 Options

-msim

Xtensa Options

-mconst16 -mno-const16
-mfused-madd  -mno-fused-madd
-mforce-no-pic
-mserialize-volatile  -mno-serialize-volatile
-mtext-section-literals  -mno-text-section-literals
-mtarget-align  -mno-target-align
-mlongcalls  -mno-longcalls

zSeries Options
See S/390 and zSeries Options.

Code Generation Options

See Options for Code Generation Conventions.

-fcall-saved-<var>reg</var>  -fcall-used-<var>reg</var>
-ffixed-<var>reg</var>  -fexceptions
-fnon-call-exceptions  -fdelete-dead-exceptions  -funwind-tables
-fasynchronous-unwind-tables
-fno-gnu-unique
-finhibit-size-directive  -finstrument-functions
-finstrument-functions-exclude-function-list=<var>sym</var>,<var>sym</var>,…
-finstrument-functions-exclude-file-list=<var>file</var>,<var>file</var>,…
-fno-common  -fno-ident
-fpcc-struct-return  -fpic  -fPIC -fpie -fPIE
-fno-jump-tables
-frecord-gcc-switches
-freg-struct-return  -fshort-enums
-fshort-double  -fshort-wchar
-fverbose-asm  -fpack-struct[=<var>n</var>]  -fstack-check
-fstack-limit-register=<var>reg</var>  -fstack-limit-symbol=<var>sym</var>
-fno-stack-limit -fsplit-stack
-fleading-underscore  -ftls-model=<var>model</var>
-fstack-reuse=<var>reuse_level</var>
-ftrapv  -fwrapv  -fbounds-check
-fvisibility -fstrict-volatile-bitfields -fsync-libcalls

Next: Overall Options, Up: Invoking GCC   [Contents][Index]


text:
using System;
using System.Threading.Tasks;
using CodeAperture.RestItEasy.Core.DataTransferObjects;
using CodeAperture.RestItEasy.Core.Contracts.Services;

namespace CodeAperture.RestItEasy.Services
{
    public class RestGateway : IRestGateway
    {
        public Task<ScenarioResponseDTO> ExecuteAsync(ScenarioRequestDTO scenarioRequest)
        {
            throw new NotImplementedException();
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin"
    tools:context=".CaptureActivity$PlaceholderFragment">

    <ImageView
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:id="@+id/CaptureImageView"
        android:maxHeight="500dp"
        android:longClickable="false"
        android:layout_above="@+id/CaptureEditText" />

    <EditText
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:id="@+id/CaptureEditText"
        android:gravity="bottom"
        android:hint="What are you grateful for?"
        android:layout_above="@+id/CaptureBtnSave"
        android:layout_alignParentLeft="true"

        />

    <Button
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Save this beautiful moment!"
        android:id="@+id/CaptureBtnSave"
        android:onClick="CaptureBtnSaveOnClick"
        android:layout_alignParentBottom="true"
        android:layout_alignParentLeft="true" />

</RelativeLayout>


text:
if [ -z "$1" ]; then
  echo "Please supply a 40-digit GitHub access token for this example."
  exit
fi

echo "Session ID for this script:"
http session
echo

http set Accepts application/vnd.travis-ci.2+json
http set User-Agent http-cli/0.1
http url https://api.travis-ci.com
echo -n "{\"github_token\":\"$1\"}" | http post auth/github 2>/dev/null
echo

if (( $? == 0 )); then
	echo Success
else
	echo Failed
fi


text:
import '../utils/boot.js';

import { dedupingMixin } from '../utils/mixin.js';
import { legacyOptimizations } from '../utils/settings.js';

const walker = document.createTreeWalker(document, NodeFilter.SHOW_ALL,
    null, false);

// 1.x backwards-compatible auto-wrapper for template type extensions
// This is a clear layering violation and gives favored-nation status to
// dom-if and dom-repeat templates.  This is a conceit we're choosing to keep
// a.) to ease 1.x backwards-compatibility due to loss of `is`, and
// b.) to maintain if/repeat capability in parser-constrained elements
//     (e.g. table, select) in lieu of native CE type extensions without
//     massive new invention in this space (e.g. directive system)
const templateExtensions = {
  'dom-if': true,
  'dom-repeat': true
};
function wrapTemplateExtension(node) {
  let is = node.getAttribute('is');
  if (is && templateExtensions[is]) {
    let t = node;
    t.removeAttribute('is');
    node = t.ownerDocument.createElement(is);
    t.parentNode.replaceChild(node, t);
    node.appendChild(t);
    while(t.attributes.length) {
      node.setAttribute(t.attributes[0].name, t.attributes[0].value);
      t.removeAttribute(t.attributes[0].name);
    }
  }
  return node;
}

function findTemplateNode(root, nodeInfo) {
  // recursively ascend tree until we hit root
  let parent = nodeInfo.parentInfo && findTemplateNode(root, nodeInfo.parentInfo);
  // unwind the stack, returning the indexed node at each level
  if (parent) {
    // note: marginally faster than indexing via childNodes
    // (http://jsperf.com/childnodes-lookup)
    walker.currentNode = parent;
    for (let n=walker.firstChild(), i=0; n; n=walker.nextSibling()) {
      if (nodeInfo.parentIndex === i++) {
        return n;
      }
    }
  } else {
    return root;
  }
}

// construct `$` map (from id annotations)
function applyIdToMap(inst, map, node, nodeInfo) {
  if (nodeInfo.id) {
    map[nodeInfo.id] = node;
  }
}

// install event listeners (from event annotations)
function applyEventListener(inst, node, nodeInfo) {
  if (nodeInfo.events && nodeInfo.events.length) {
    for (let j=0, e$=nodeInfo.events, e; (j<e$.length) && (e=e$[j]); j++) {
      inst._addMethodEventListenerToNode(node, e.name, e.value, inst);
    }
  }
}

// push configuration references at configure time
function applyTemplateContent(inst, node, nodeInfo) {
  if (nodeInfo.templateInfo) {
    node._templateInfo = nodeInfo.templateInfo;
  }
}

function createNodeEventHandler(context, eventName, methodName) {
  // Instances can optionally have a _methodHost which allows redirecting where
  // to find methods. Currently used by `templatize`.
  context = context._methodHost || context;
  let handler = function(e) {
    if (context[methodName]) {
      context[methodName](e, e.detail);
    } else {
      console.warn('listener method `' + methodName + '` not defined');
    }
  };
  return handler;
}

/**
 * Element mixin that provides basic template parsing and stamping, including
 * the following template-related features for stamped templates:
 *
 * - Declarative event listeners (`on-eventname="listener"`)
 * - Map of node id's to stamped node instances (`this.$.id`)
 * - Nested template content caching/removal and re-installation (performance
 *   optimization)
 *
 * @mixinFunction
 * @polymer
 * @summary Element class mixin that provides basic template parsing and stamping
 */
export const TemplateStamp = dedupingMixin(superClass => {

  /**
   * @polymer
   * @mixinClass
   * @implements {Polymer_TemplateStamp}
   */
  class TemplateStamp extends superClass {

    /**
     * Scans a template to produce template metadata.
     *
     * Template-specific metadata are stored in the object returned, and node-
     * specific metadata are stored in objects in its flattened `nodeInfoList`
     * array.  Only nodes in the template that were parsed as nodes of
     * interest contain an object in `nodeInfoList`.  Each `nodeInfo` object
     * contains an `index` (`childNodes` index in parent) and optionally
     * `parent`, which points to node info of its parent (including its index).
     *
     * The template metadata object returned from this method has the following
     * structure (many fields optional):
     *
     * ```js
     *   {
     *     // Flattened list of node metadata (for nodes that generated metadata)
     *     nodeInfoList: [
     *       {
     *         // `id` attribute for any nodes with id's for generating `$` map
     *         id: {string},
     *         // `on-event="handler"` metadata
     *         events: [
     *           {
     *             name: {string},   // event name
     *             value: {string},  // handler method name
     *           }, ...
     *         ],
     *         // Notes when the template contained a `<slot>` for shady DOM
     *         // optimization purposes
     *         hasInsertionPoint: {boolean},
     *         // For nested `<template>`` nodes, nested template metadata
     *         templateInfo: {object}, // nested template metadata
     *         // Metadata to allow efficient retrieval of instanced node
     *         // corresponding to this metadata
     *         parentInfo: {number},   // reference to parent nodeInfo>
     *         parentIndex: {number},  // index in parent's `childNodes` collection
     *         infoIndex: {number},    // index of this `nodeInfo` in `templateInfo.nodeInfoList`
     *       },
     *       ...
     *     ],
     *     // When true, the template had the `strip-whitespace` attribute
     *     // or was nested in a template with that setting
     *     stripWhitespace: {boolean},
     *     // For nested templates, nested template content is moved into
     *     // a document fragment stored here; this is an optimization to
     *     // avoid the cost of nested template cloning
     *     content: {DocumentFragment}
     *   }
     * ```
     *
     * This method kicks off a recursive treewalk as follows:
     *
     * ```
     *    _parseTemplate <---------------------+
     *      _parseTemplateContent              |
     *        _parseTemplateNode  <------------|--+
     *          _parseTemplateNestedTemplate --+  |
     *          _parseTemplateChildNodes ---------+
     *          _parseTemplateNodeAttributes
     *            _parseTemplateNodeAttribute
     *
     * ```
     *
     * These methods may be overridden to add custom metadata about templates
     * to either `templateInfo` or `nodeInfo`.
     *
     * Note that this method may be destructive to the template, in that
     * e.g. event annotations may be removed after being noted in the
     * template metadata.
     *
     * @param {!HTMLTemplateElement} template Template to parse
     * @param {TemplateInfo=} outerTemplateInfo Template metadata from the outer
     *   template, for parsing nested templates
     * @return {!TemplateInfo} Parsed template metadata
     */
    static _parseTemplate(template, outerTemplateInfo) {
      // since a template may be re-used, memo-ize metadata
      if (!template._templateInfo) {
        let templateInfo = template._templateInfo = {};
        templateInfo.nodeInfoList = [];
        templateInfo.stripWhiteSpace = legacyOptimizations ||
          (outerTemplateInfo && outerTemplateInfo.stripWhiteSpace) ||
          template.hasAttribute('strip-whitespace');
        this._parseTemplateContent(template, templateInfo, {parent: null});
      }
      return template._templateInfo;
    }

    static _parseTemplateContent(template, templateInfo, nodeInfo) {
      return this._parseTemplateNode(template.content, templateInfo, nodeInfo);
    }

    /**
     * Parses template node and adds template and node metadata based on
     * the current node, and its `childNodes` and `attributes`.
     *
     * This method may be overridden to add custom node or template specific
     * metadata based on this node.
     *
     * @param {Node} node Node to parse
     * @param {!TemplateInfo} templateInfo Template metadata for current template
     * @param {!NodeInfo} nodeInfo Node metadata for current template.
     * @return {boolean} `true` if the visited node added node-specific
     *   metadata to `nodeInfo`
     */
    static _parseTemplateNode(node, templateInfo, nodeInfo) {
      let noted;
      let element = /** @type {Element} */(node);
      if (element.localName == 'template' && !element.hasAttribute('preserve-content')) {
        noted = this._parseTemplateNestedTemplate(element, templateInfo, nodeInfo) || noted;
      } else if (element.localName === 'slot') {
        // For ShadyDom optimization, indicating there is an insertion point
        templateInfo.hasInsertionPoint = true;
      }
      walker.currentNode = element;
      if (walker.firstChild()) {
        noted = this._parseTemplateChildNodes(element, templateInfo, nodeInfo) || noted;
      }
      if (element.hasAttributes && element.hasAttributes()) {
        noted = this._parseTemplateNodeAttributes(element, templateInfo, nodeInfo) || noted;
      }
      return noted;
    }

    /**
     * Parses template child nodes for the given root node.
     *
     * This method also wraps whitelisted legacy template extensions
     * (`is="dom-if"` and `is="dom-repeat"`) with their equivalent element
     * wrappers, collapses text nodes, and strips whitespace from the template
     * if the `templateInfo.stripWhitespace` setting was provided.
     *
     * @param {Node} root Root node whose `childNodes` will be parsed
     * @param {!TemplateInfo} templateInfo Template metadata for current template
     * @param {!NodeInfo} nodeInfo Node metadata for current template.
     * @return {void}
     */
    static _parseTemplateChildNodes(root, templateInfo, nodeInfo) {
      if (root.localName === 'script' || root.localName === 'style') {
        return;
      }
      walker.currentNode = root;
      for (let node=walker.firstChild(), parentIndex=0, next; node; node=next) {
        // Wrap templates
        if (node.localName == 'template') {
          node = wrapTemplateExtension(node);
        }
        // collapse adjacent textNodes: fixes an IE issue that can cause
        // text nodes to be inexplicably split =(
        // note that root.normalize() should work but does not so we do this
        // manually.
        walker.currentNode = node;
        next = walker.nextSibling();
        if (node.nodeType === Node.TEXT_NODE) {
          let /** Node */ n = next;
          while (n && (n.nodeType === Node.TEXT_NODE)) {
            node.textContent += n.textContent;
            next = walker.nextSibling();
            root.removeChild(n);
            n = next;
          }
          // optionally strip whitespace
          if (templateInfo.stripWhiteSpace && !node.textContent.trim()) {
            root.removeChild(node);
            continue;
          }
        }
        let childInfo = { parentIndex, parentInfo: nodeInfo };
        if (this._parseTemplateNode(node, templateInfo, childInfo)) {
          childInfo.infoIndex = templateInfo.nodeInfoList.push(/** @type {!NodeInfo} */(childInfo)) - 1;
        }
        // Increment if not removed
        walker.currentNode = node;
        if (walker.parentNode()) {
          parentIndex++;
        }
      }
    }

    /**
     * Parses template content for the given nested `<template>`.
     *
     * Nested template info is stored as `templateInfo` in the current node's
     * `nodeInfo`. `template.content` is removed and stored in `templateInfo`.
     * It will then be the responsibility of the host to set it back to the
     * template and for users stamping nested templates to use the
     * `_contentForTemplate` method to retrieve the content for this template
     * (an optimization to avoid the cost of cloning nested template content).
     *
     * @param {HTMLTemplateElement} node Node to parse (a <template>)
     * @param {TemplateInfo} outerTemplateInfo Template metadata for current template
     *   that includes the template `node`
     * @param {!NodeInfo} nodeInfo Node metadata for current template.
     * @return {boolean} `true` if the visited node added node-specific
     *   metadata to `nodeInfo`
     */
    static _parseTemplateNestedTemplate(node, outerTemplateInfo, nodeInfo) {
      let templateInfo = this._parseTemplate(node, outerTemplateInfo);
      let content = templateInfo.content =
        node.content.ownerDocument.createDocumentFragment();
      content.appendChild(node.content);
      nodeInfo.templateInfo = templateInfo;
      return true;
    }

    /**
     * Parses template node attributes and adds node metadata to `nodeInfo`
     * for nodes of interest.
     *
     * @param {Element} node Node to parse
     * @param {TemplateInfo} templateInfo Template metadata for current template
     * @param {NodeInfo} nodeInfo Node metadata for current template.
     * @return {boolean} `true` if the visited node added node-specific
     *   metadata to `nodeInfo`
     */
    static _parseTemplateNodeAttributes(node, templateInfo, nodeInfo) {
      // Make copy of original attribute list, since the order may change
      // as attributes are added and removed
      let noted = false;
      let attrs = Array.from(node.attributes);
      for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
        noted = this._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, a.name, a.value) || noted;
      }
      return noted;
    }

    /**
     * Parses a single template node attribute and adds node metadata to
     * `nodeInfo` for attributes of interest.
     *
     * This implementation adds metadata for `on-event="handler"` attributes
     * and `id` attributes.
     *
     * @param {Element} node Node to parse
     * @param {!TemplateInfo} templateInfo Template metadata for current template
     * @param {!NodeInfo} nodeInfo Node metadata for current template.
     * @param {string} name Attribute name
     * @param {string} value Attribute value
     * @return {boolean} `true` if the visited node added node-specific
     *   metadata to `nodeInfo`
     */
    static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
      // events (on-*)
      if (name.slice(0, 3) === 'on-') {
        node.removeAttribute(name);
        nodeInfo.events = nodeInfo.events || [];
        nodeInfo.events.push({
          name: name.slice(3),
          value
        });
        return true;
      }
      // static id
      else if (name === 'id') {
        nodeInfo.id = value;
        return true;
      }
      return false;
    }

    /**
     * Returns the `content` document fragment for a given template.
     *
     * For nested templates, Polymer performs an optimization to cache nested
     * template content to avoid the cost of cloning deeply nested templates.
     * This method retrieves the cached content for a given template.
     *
     * @param {HTMLTemplateElement} template Template to retrieve `content` for
     * @return {DocumentFragment} Content fragment
     */
    static _contentForTemplate(template) {
      let templateInfo = /** @type {HTMLTemplateElementWithInfo} */ (template)._templateInfo;
      return (templateInfo && templateInfo.content) || template.content;
    }

    /**
     * Clones the provided template content and returns a document fragment
     * containing the cloned dom.
     *
     * The template is parsed (once and memoized) using this library's
     * template parsing features, and provides the following value-added
     * features:
     * * Adds declarative event listeners for `on-event="handler"` attributes
     * * Generates an "id map" for all nodes with id's under `$` on returned
     *   document fragment
     * * Passes template info including `content` back to templates as
     *   `_templateInfo` (a performance optimization to avoid deep template
     *   cloning)
     *
     * Note that the memoized template parsing process is destructive to the
     * template: attributes for bindings and declarative event listeners are
     * removed after being noted in notes, and any nested `<template>.content`
     * is removed and stored in notes as well.
     *
     * @param {!HTMLTemplateElement} template Template to stamp
     * @return {!StampedTemplate} Cloned template content
     */
    _stampTemplate(template) {
      // Polyfill support: bootstrap the template if it has not already been
      if (template && !template.content &&
          window.HTMLTemplateElement && HTMLTemplateElement.decorate) {
        HTMLTemplateElement.decorate(template);
      }
      let templateInfo = this.constructor._parseTemplate(template);
      let nodeInfo = templateInfo.nodeInfoList;
      let content = templateInfo.content || template.content;
      let dom = /** @type {DocumentFragment} */ (document.importNode(content, true));
      // NOTE: ShadyDom optimization indicating there is an insertion point
      dom.__noInsertionPoint = !templateInfo.hasInsertionPoint;
      let nodes = dom.nodeList = new Array(nodeInfo.length);
      dom.$ = {};
      for (let i=0, l=nodeInfo.length, info; (i<l) && (info=nodeInfo[i]); i++) {
        let node = nodes[i] = findTemplateNode(dom, info);
        applyIdToMap(this, dom.$, node, info);
        applyTemplateContent(this, node, info);
        applyEventListener(this, node, info);
      }
      dom = /** @type {!StampedTemplate} */(dom); // eslint-disable-line no-self-assign
      return dom;
    }

    /**
     * Adds an event listener by method name for the event provided.
     *
     * This method generates a handler function that looks up the method
     * name at handling time.
     *
     * @param {!Node} node Node to add listener on
     * @param {string} eventName Name of event
     * @param {string} methodName Name of method
     * @param {*=} context Context the method will be called on (defaults
     *   to `node`)
     * @return {Function} Generated handler function
     */
    _addMethodEventListenerToNode(node, eventName, methodName, context) {
      context = context || node;
      let handler = createNodeEventHandler(context, eventName, methodName);
      this._addEventListenerToNode(node, eventName, handler);
      return handler;
    }

    /**
     * Override point for adding custom or simulated event handling.
     *
     * @param {!Node} node Node to add event listener to
     * @param {string} eventName Name of event
     * @param {function(!Event):void} handler Listener function to add
     * @return {void}
     */
    _addEventListenerToNode(node, eventName, handler) {
      node.addEventListener(eventName, handler);
    }

    /**
     * Override point for adding custom or simulated event handling.
     *
     * @param {!Node} node Node to remove event listener from
     * @param {string} eventName Name of event
     * @param {function(!Event):void} handler Listener function to remove
     * @return {void}
     */
    _removeEventListenerFromNode(node, eventName, handler) {
      node.removeEventListener(eventName, handler);
    }

  }

  return TemplateStamp;

});


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Mycotaxon 5(2): 401 (1977)

#### Original name
Coleosporium pacificum Cummins

### Remarks
null


text:
<!DOCTYPE html>

        <meta charset="utf-8">
        <title>Extended User Interface Test Suite</title>

        <link rel="stylesheet" href="../libs/qunit/qunit.css" media="screen">
        <link rel="stylesheet" href="../libs/jquery-ui/css/smoothness/jquery-ui-1.10.1.custom.css">


text:
package models

import (
	"encoding/base64"
	"time"

	"github.com/dgrijalva/jwt-go"
	"github.com/dtop/go.ginject"
	"github.com/satori/go.uuid"
	"gopkg.in/oauth2.v3"
)

// TokenGenerator is the struct for the token generator
type TokenGenerator struct {
	keyProvider KeyProvider
}

// NewTokenGenerator creates a new token gen including all deps
func NewTokenGenerator(dep ginject.Injector) *TokenGenerator {

	kp, err := NewKeyProvider(dep)
	if err != nil {
		panic(err)
	}

	return &TokenGenerator{keyProvider: kp}
}

// Token generates the actual token
func (tg *TokenGenerator) Token(data *oauth2.GenerateBasic, isGenRefresh bool) (access, refresh string, err error) {

	ti := data.TokenInfo

	claims := make(jwt.MapClaims)
	// default fields
	claims["iss"] = "DemoIAM"
	claims["aud"] = "DemoServices"
	claims["exp"] = time.Now().Add(ti.GetAccessExpiresIn()).Unix()
	claims["iat"] = time.Now().Unix()
	claims["nbf"] = ""
	claims["sub"] = ""
	claims["jti"] = data.UserID
	// own fields
	claims["sco"] = ti.GetScope()

	token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
	access, err = token.SignedString(tg.keyProvider.GetPrivateKey())
	if err != nil {
		return
	}

	if isGenRefresh {

		refresh = base64.URLEncoding.EncodeToString(uuid.NewV5(uuid.NewV4(), access).Bytes())
	}
	return
}


text:
#ifndef MODULES_AUDIO_PROCESSING_TYPING_DETECTION_H_
#define MODULES_AUDIO_PROCESSING_TYPING_DETECTION_H_

namespace webrtc {

class TypingDetection {
 public:
  TypingDetection();
  virtual ~TypingDetection();

  // Run the detection algortihm. Shall be called every 10 ms. Returns true if
  // typing is detected, or false if not, based on the update period as set with
  // SetParameters(). See |report_detection_update_period_| description below.
  bool Process(bool key_pressed, bool vad_activity);

  // Gets the time in seconds since the last detection.
  int TimeSinceLastDetectionInSeconds();

  // Sets the algorithm parameters. A parameter value of 0 leaves it unchanged.
  // See the correspondning member variables below for descriptions.
  void SetParameters(int time_window,
                     int cost_per_typing,
                     int reporting_threshold,
                     int penalty_decay,
                     int type_event_delay,
                     int report_detection_update_period);

 private:
  int time_active_;
  int time_since_last_typing_;
  int penalty_counter_;

  // Counter since last time the detection status reported by Process() was
  // updated. See also |report_detection_update_period_|.
  int counter_since_last_detection_update_;

  // The detection status to report. Updated every
  // |report_detection_update_period_| call to Process().
  bool detection_to_report_;

  // What |detection_to_report_| should be set to next time it is updated.
  bool new_detection_to_report_;

  // Settable threshold values.

  // Number of 10 ms slots accepted to count as a hit.
  int time_window_;

  // Penalty added for a typing + activity coincide.
  int cost_per_typing_;

  // Threshold for |penalty_counter_|.
  int reporting_threshold_;

  // How much we reduce |penalty_counter_| every 10 ms.
  int penalty_decay_;

  // How old typing events we allow.
  int type_event_delay_;

  // Settable update period.

  // Number of 10 ms slots between each update of the detection status returned
  // by Process(). This inertia added to the algorithm is usually desirable and
  // provided so that consumers of the class don't have to implement that
  // themselves if they don't wish.
  // If set to 1, each call to Process() will return the detection status for
  // that 10 ms slot.
  // If set to N (where N > 1), the detection status returned from Process()
  // will remain the same until Process() has been called N times. Then, if none
  // of the last N calls to Process() has detected typing for each respective
  // 10 ms slot, Process() will return false. If at least one of the last N
  // calls has detected typing, Process() will return true. And that returned
  // status will then remain the same until the next N calls have been done.
  int report_detection_update_period_;
};

}  // namespace webrtc

#endif  // #ifndef MODULES_AUDIO_PROCESSING_TYPING_DETECTION_H_


text:
package org.apache.lucene.analysis.miscellaneous;

import java.util.Map;

import org.apache.lucene.analysis.util.AbstractAnalysisFactory;
import org.apache.lucene.analysis.util.MultiTermAwareComponent;
import org.apache.lucene.analysis.util.TokenFilterFactory;
import org.apache.lucene.analysis.miscellaneous.ASCIIFoldingFilter;
import org.apache.lucene.analysis.TokenStream;

/**
 * Factory for {@link ASCIIFoldingFilter}.
 *

 * <fieldType name="text_ascii" class="solr.TextField" positionIncrementGap="100">
 *   <analyzer>
 *     <tokenizer class="solr.WhitespaceTokenizerFactory"/>
 *     <filter class="solr.ASCIIFoldingFilterFactory"/>
 *   </analyzer>
 * </fieldType>

 */
public class ASCIIFoldingFilterFactory extends TokenFilterFactory implements MultiTermAwareComponent {

  /** Creates a new ASCIIFoldingFilterFactory */
  public ASCIIFoldingFilterFactory(Map<String,String> args) {
    super(args);
    if (!args.isEmpty()) {
      throw new IllegalArgumentException("Unknown parameters: " + args);
    }
  }

  @Override
  public ASCIIFoldingFilter create(TokenStream input) {
    return new ASCIIFoldingFilter(input);
  }

  @Override
  public AbstractAnalysisFactory getMultiTermComponent() {
    return this;
  }
}


text:
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html
     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

  <title>calculate_length! (GData::HTTP::Request)</title>
  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
  <link rel="stylesheet" href="../../../.././rdoc-style.css" type="text/css" media="screen" />

# File lib/gdata/http/request.rb, line 64
      def calculate_length!
        if not @headers['Content-Length'] and not chunked?
          if @body
            @headers['Content-Length'] = @body.length
          else
            @headers['Content-Length'] = 0
          end
        end
      end


text:
import {ENGINE} from './engine';
import {env} from './environment';
import {Tensor} from './tensor';
import {DataType, TensorLike} from './types';
import {assert, flatten, inferDtype, isTypedArray, toTypedArray} from './util';

export function inferShape(val: TensorLike, dtype?: DataType): number[] {
  let firstElem: typeof val = val;

  if (isTypedArray(val)) {
    return dtype === 'string' ? [] : [val.length];
  }
  if (!Array.isArray(val)) {
    return [];  // Scalar.
  }
  const shape: number[] = [];

  while (Array.isArray(firstElem) ||
         isTypedArray(firstElem) && dtype !== 'string') {
    shape.push(firstElem.length);
    firstElem = firstElem[0];
  }
  if (Array.isArray(val) &&
      env().getBool('TENSORLIKE_CHECK_SHAPE_CONSISTENCY')) {
    deepAssertShapeConsistency(val, shape, []);
  }

  return shape;
}

function deepAssertShapeConsistency(
    val: TensorLike, shape: number[], indices: number[]) {
  indices = indices || [];
  if (!(Array.isArray(val)) && !isTypedArray(val)) {
    assert(
        shape.length === 0,
        () => `Element arr[${indices.join('][')}] is a primitive, ` +
            `but should be an array/TypedArray of ${shape[0]} elements`);
    return;
  }
  assert(
      shape.length > 0,
      () => `Element arr[${indices.join('][')}] should be a primitive, ` +
          `but is an array of ${val.length} elements`);
  assert(
      val.length === shape[0],
      () => `Element arr[${indices.join('][')}] should have ${shape[0]} ` +
          `elements, but has ${val.length} elements`);
  const subShape = shape.slice(1);
  for (let i = 0; i < val.length; ++i) {
    deepAssertShapeConsistency(val[i], subShape, indices.concat(i));
  }
}

function assertDtype(
    expectedDtype: DataType|'numeric', actualDType: DataType, argName: string,
    functionName: string) {
  if (expectedDtype == null) {
    return;
  }
  if (expectedDtype !== 'numeric' && expectedDtype !== actualDType ||
      expectedDtype === 'numeric' && actualDType === 'string') {
    throw new Error(
        `Argument '${argName}' passed to '${functionName}' must ` +
        `be ${expectedDtype} tensor, but got ${actualDType} tensor`);
  }
}

export function convertToTensor<T extends Tensor>(
    x: T|TensorLike, argName: string, functionName: string,
    parseAsDtype: DataType|'numeric' = 'numeric'): T {
  if (x instanceof Tensor) {
    assertDtype(parseAsDtype, x.dtype, argName, functionName);
    return x;
  }
  let inferredDtype = inferDtype(x);
  // If the user expects a bool/int/float, use that info to update the
  // inferredDtype when it is not a string.
  if (inferredDtype !== 'string' &&
      ['bool', 'int32', 'float32'].indexOf(parseAsDtype) >= 0) {
    inferredDtype = parseAsDtype as DataType;
  }
  assertDtype(parseAsDtype, inferredDtype, argName, functionName);

  if ((x == null) ||
      (!isTypedArray(x) && !Array.isArray(x) && typeof x !== 'number' &&
       typeof x !== 'boolean' && typeof x !== 'string')) {
    const type = x == null ? 'null' : (x as {}).constructor.name;
    throw new Error(
        `Argument '${argName}' passed to '${functionName}' must be a ` +
        `Tensor or TensorLike, but got '${type}'`);
  }
  const inferredShape = inferShape(x, inferredDtype);
  if (!isTypedArray(x) && !Array.isArray(x)) {
    x = [x] as number[];
  }
  const skipTypedArray = true;
  const values = inferredDtype !== 'string' ?
      toTypedArray(x, inferredDtype as DataType, env().getBool('DEBUG')) :
      flatten(x as string[], [], skipTypedArray) as string[];
  return ENGINE.makeTensor(values, inferredShape, inferredDtype) as T;
}

export function convertToTensorArray<T extends Tensor>(
    arg: Array<T|TensorLike>, argName: string, functionName: string,
    parseAsDtype: DataType|'numeric' = 'numeric'): T[] {
  if (!Array.isArray(arg)) {
    throw new Error(
        `Argument ${argName} passed to ${functionName} must be a ` +
        '`Tensor[]` or `TensorLike[]`');
  }
  const tensors = arg as T[];
  return tensors.map(
      (t, i) => convertToTensor(t, `${argName}[${i}]`, functionName),
      parseAsDtype);
}


text:
<?php
$this->pageTitle=t('Manage Material Information');
$this->pageHint=t('Here you can manage all Info for this Material');

?>

<?php $this->widget('cmswidgets.ModelManageWidget',array('model_name'=>'Pmaterial')); ?>


text:
import React from "react"
import './style.css';
import {Link} from "gatsby";
import _capitalize from "lodash/capitalize"
import Image from "../../layout/image"

const LanguageCard = ({ data }) => {
  return (

        {data.map(item => {
          return (

              <Link to={`/docs/${item.node.id}/`}>

                    <Image path={`flags/${item.node.slug}.png`} className="card-title rounded-circle w-100px" alt={item.node.slug} />

                    {_capitalize(item.node.name)} ({item.node.id})

                  {item.node.authors && (
                    item.node.authors.map(author => {
                      return (
                        <React.Fragment key={author.id}>
                          {author.github_avatar && }
                        </React.Fragment>
                      )
                    })
                  )}

              </Link>

          )
        })}

  )
}

export default LanguageCard;


text:
<?php

namespace Grid\Banner\Model\Banner\Structure;

use Zork\Model\Structure\MapperAwareAbstract;
use Grid\Banner\Model\Banner\StructureInterface;

/**
 * Structure
 *
 * @author David Pozsar <david.pozsar@megaweb.hu>
 */
class ProxyBase extends MapperAwareAbstract
             implements StructureInterface
{

    /**
     * ID of the banner
     *
     * @val int|null
     */
    protected $id;

    /**
     * Type of the banner
     *
     * @var string|null
     */
    public $type;

    /**
     * Get ID of the banner
     *
     * @return int|null
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Get type of the banner
     *
     * @return string|null
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * Get service locator
     *
     * @return \Zend\ServiceManager\ServiceLocatorInterface
     */
    public function getServiceLocator()
    {
        return $this->getMapper()
                    ->getServiceLocator();
    }

}


text:
module Protocool
  extend self

  def https
    use_ssl? ? 'https' : 'http'
  end

  def protocol
    "#{Protocool.https}://"
  end

  private

  def use_ssl?
    # Allow the user to override any defaults
    # This is useful for booting a Rails app with production environment locally
    return false if ENV['PROTOCOOL_FORCE_INSECURE'] == 'true'
    # Let the Rails config decide
    return true if Rails.respond_to?(:application) && Rails.application.config.force_ssl
    # Otherwise use default
    !Rails.env.development? && !Rails.env.test?
  end
end


text:
package zzb.storage

import com.mongodb.casbah.{query, Imports}
import com.mongodb.casbah.query.dsl.QueryExpressionObject
import  com.mongodb.casbah.query.Imports._
import com.typesafe.scalalogging.slf4j.Logging
import zzb.datatype.StructPath

/**
 * todo:
 * @author 何伟波
 * @since  0.1.0
 */
trait DBObjectHelper{

  val  gtStringMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"gt") if value.isInstanceOf[String]=> Some( key $gt value.toString )
  }
  val  gtDoubleMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"gt") if value.isInstanceOf[Double]=> Some( key $gt value.asInstanceOf[Double] )
  }
  val  gtIntMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"gt") if value.isInstanceOf[Int]=> Some( key $gt value.toString.toDouble )
  }
  val  gtBooleanMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"gt") if value.isInstanceOf[Boolean]=> Some( key $gt value.toString.toBoolean )
  }
  val  ltStringMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"lt") if value.isInstanceOf[String]=> Some( key $lt value.toString )
  }
  val  ltDoubleMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"lt") if value.isInstanceOf[Double]=> Some( key $lt value.asInstanceOf[Double] )
  }
  val  ltIntMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"lt") if value.isInstanceOf[Int]=> Some( key $lt value.toString.toDouble )
  }
  val  ltBooleanMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"lt") if value.isInstanceOf[Boolean]=> Some( key $lt value.toString.toBoolean )
  }
  val  gteStringMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"gte") if value.isInstanceOf[String]=> Some( key $gte value.toString )
  }
  val  gteDoubleMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"gte") if value.isInstanceOf[Double]=> Some( key $gte value.asInstanceOf[Double] )
  }
  val  gteIntMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"gte") if value.isInstanceOf[Int]=> Some( key $gte value.toString.toDouble )
  }
  val  gteBooleanMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"gte") if value.isInstanceOf[Boolean]=> Some( key $gte value.toString.toBoolean )
  }
  val  lteStringMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"lte") if value.isInstanceOf[String]=> Some( key $lte value.toString )
  }
  val  lteDoubleMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"lte") if value.isInstanceOf[Double]=> Some( key $lte value.asInstanceOf[Double] )
  }
  val  lteIntMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"lte") if value.isInstanceOf[Int]=> Some( key $lte value.toString.toDouble )
  }
  val  lteBooleanMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"lte") if value.isInstanceOf[Boolean]=> Some( key $lte value.toString.toBoolean )
  }
  val  eqStringMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"eq") if value.isInstanceOf[String]=> Some( key $eq value.toString )
  }
  val  eqDoubleMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"eq") if value.isInstanceOf[Double]=> Some( key $eq value.asInstanceOf[Double] )
  }
  val  eqIntMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"eq") if value.isInstanceOf[Int]=> Some( key $eq value.toString.toDouble )
  }
  val  eqBooleanMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case (key,value,"eq") if value.isInstanceOf[Boolean]=> Some( key $eq value.toString.toBoolean )
  }
  val  otherMethod :PartialFunction[(String,Any,String),Option[Imports.DBObject with QueryExpressionObject]]={
    case _=> None
  }

  val gtfilterMethod= gtStringMethod orElse gtDoubleMethod orElse gtIntMethod  orElse gtBooleanMethod
  val gtefilterMethod=gteStringMethod orElse gteDoubleMethod orElse gteIntMethod  orElse gteBooleanMethod
  val ltfilterMethod=ltStringMethod orElse ltDoubleMethod orElse ltIntMethod    orElse ltBooleanMethod
  val ltefilterMethod=lteStringMethod orElse lteDoubleMethod orElse lteIntMethod     orElse lteBooleanMethod
  val eqfilterMethod=eqStringMethod orElse eqDoubleMethod orElse eqIntMethod      orElse eqBooleanMethod
  val dbObjectFilter= gtfilterMethod orElse gtefilterMethod orElse ltfilterMethod orElse ltefilterMethod orElse eqfilterMethod orElse otherMethod

  def structPathToString(structPath:StructPath)=
    structPath.relativeStr.drop(1).replace("/",".")

  /**
   * 创建and的查询条件
   * @param params
   * @return
   */
  def makeAndFilter(params:Imports.DBObject *): query.Imports.DBObject ={
    $and(params: _*)
  }

  /**
   * 创建and的查询条件
   * @param params
   * @return
   */
  def makeAndFilter(params:List[Imports.DBObject]): query.Imports.DBObject ={
    makeAndFilter(params: _*)
  }

  /**
   * 创建or的查询条件
   * @param params
   * @return
   */
  def makeOrFilter(params:Imports.DBObject *): query.Imports.DBObject ={
    $or(params: _*)
  }

  /**
   * 创建or的查询条件
   * @param params
   * @return
   */
  def makeOrFilter(params:List[Imports.DBObject]): query.Imports.DBObject ={
    makeOrFilter(params: _*)
  }

  /**
   * 根据条件去生成查询条件
   * @param key
   * @param value
   * @param option  eq:相等,lt:小于, lte:小于等于 , gt:大于 ,gte:大于等于 ,
   * @return
   */
  def makeFilterByConditionName(key:String , value:Any,option:String): Option[query.Imports.DBObject]={
        dbObjectFilter(key,value,option)
  }

  /**
   * 根据条件去生成查询条件
   * @param structPath
   * @param value
   * @param option
   * @return
   */
  def makeFilterByConditionName(structPath:StructPath , value:Any,option:String): Option[query.Imports.DBObject]={
        val key = structPathToString(structPath)
        dbObjectFilter(key,value,option)
  }

  /**
   * 创建小于的条件
   * @param key
   * @param value
   * @return
   */
  def makeLtFilter(key:String , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(key,value,"lt")
  }

  /**
   * 创建小于的条件
   * @param structPath
   * @param value
   * @return
   */
  def makeLtFilter(structPath:StructPath , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(structPath,value,"lt")
  }

  /**
   * 创建小于等于的条件
   * @param key
   * @param value
   * @return
   */
  def makeLteFilter(key:String , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(key,value,"lte")
  }

  /**
   * 创建小于等于的条件
   * @param structPath
   * @param value
   * @return
   */
  def makeLteFilter(structPath:StructPath , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(structPath,value,"lte")
  }
  /**
   * 创建大于的条件
   * @param key
   * @param value
   * @return
   */
  def makeGtFilter(key:String , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(key,value,"gt")
  }

  /**
   * 创建大于的条件
   * @param structPath
   * @param value
   * @return
   */
  def makeGtFilter(structPath:StructPath , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(structPath,value,"gt")
  }

  /**
   * 创建大于等于的条件
   * @param key
   * @param value
   * @return
   */
  def makeGteFilter(key:String , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(key,value,"gte")
  }

  /**
   * 创建大于等于的条件
   * @param structPath
   * @param value
   * @return
   */
  def makeGteFilter(structPath:StructPath , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(structPath,value,"gte")
  }

  /**
   * 创建等于的条件
   * @param key
   * @param value
   * @return
   */
  def makeEqFilter(key:String , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(key,value,"eq")
  }

  /**
   * 创建等于的条件
   * @param structPath
   * @param value
   * @return
   */
  def makeEqFilter(structPath:StructPath , value:Any): Option[query.Imports.DBObject]={
    makeFilterByConditionName(structPath,value,"eq")
  }
}


text:
class Admin::SessionsController < Devise::SessionsController
  helper AdminHelper
  layout 'admin/application'
end


text:
<?php

class EducationMajor extends Eloquent {

	protected $table = "education_majors";
	protected $guarded = array();
}


text:
require "rr"
require "pry"
require "timecop"
require "support/element_test_macros"
require "support/part_test_macros"
require "support/property_test_macros"
require "support/value_property_test_macros"

require "simplecov"
SimpleCov.start

require "openxml/drawingml"
require "nokogiri"


text:
var driver = require('selenium-webdriver');

var deferred = driver.promise.defer();
deferred.then(function(data){
	console.log("I am the promised action - the data passed to me was: " + data);
});

setTimeout(function() {
	deferred.fulfill('engineering report - shields at 50% captain');

}, 4000);


text:
namespace oakvr
{
	namespace profiler
	{
		struct ProfileId
		{
			std::string name; // id with which to identify this profiling data
			std::string groupName; // group name in which this data is categorized
			std::string funcName; // function name in which from which the data is gathered
			std::string location; // location inside of code (file name + line number)
		};

		struct ProfilingData
		{
			ProfileId id;
			size_t hits = 0; // number of times the piece of code corresponding to this data was executed
			uint64_t minTime = -1; //[µs]
			uint64_t maxTime = 0; //[µs]
			uint64_t avgTime = 0; //[µs]
			uint64_t latestTime = 0; //[µs]
			uint64_t totalTime = 0; //[µs]
		};
	}
} // namespace oakvr


text:
package org.mifos.accounts.fund.exception;

import org.mifos.framework.exceptions.ApplicationException;

public class FundException extends ApplicationException {

    public FundException(Throwable cause) {
        super(cause);

    }

    public FundException(String key) {
        super(key);

    }

}


text:
WITH billing as (
	SELECT artifact.luid as artifactluid, process.daterun as daterun
	FROM processiotracker, process, processtype, artifact
	WHERE processiotracker.processid=process.processid
	AND process.typeid=processtype.typeid
	AND processtype.displayname='Billing'
	AND processiotracker.inputartifactid=artifact.artifactid
	AND process.daterun >= '$financialyyyymm-01'
)
-- SELECT -------------------------------------------------------------------------
SELECT distinct

researcher.email as useremail,

-- col1: PPMS email
case when ludf2.udfvalue = 'n/a' then researcher.email
     else ludf2.udfvalue
end as ppmsemail,

-- col2: PPMS cost code
case when ludf1.udfvalue = 'Collaboration' then '000194'
     else audf4.udfvalue
end as ppmscostcode,

-- col3: PPMS service
case
	when itype.name like 'Hiseq%' then
		case
			when pudf3.udfvalue like '______NXX' then 'HiSeq' || '_' || case when pudf2.udfvalue is null then 'SE' else 'PE' end ||
				case
					when cast(pudf1.udfvalue as int) = 26 and cast(pudf2.udfvalue as int) = 98 then '75'
					when cast(pudf1.udfvalue as int) = 98 and cast(pudf2.udfvalue as int) = 10 then '75'
					when cast(pudf1.udfvalue as int) = 114 and cast(pudf2.udfvalue as int) = 98 then '125'
					else pudf1.udfvalue
				end
	    when pudf3.udfvalue like '______CXX' then 'HiSeq2000' || '_' || case when pudf2.udfvalue is null then 'SE' else 'PE' end || pudf1.udfvalue
	    when pudf3.udfvalue like '______DXX' then 'HiSeqRapid' || '_' || case when pudf2.udfvalue is null then 'SE' else 'PE' end || pudf1.udfvalue
			when pudf3.udfvalue like '______CXY' then 'HiSeqRapid' || '_' ||
				case when pudf2.udfvalue is null then 'SE' else 'PE' end ||
				case
					when cast(pudf1.udfvalue as int) <= 75 then '75'
					when cast(pudf1.udfvalue as int) > 75 and cast(pudf1.udfvalue as int) <= 125 then '125'
					else pudf1.udfvalue
				end
			when pudf3.udfvalue like '______BXX' then 'HiSeq4000' || '_' ||
		  	case when pudf2.udfvalue is null then 'SE' || pudf1.udfvalue else 'PE' ||
					case
						when cast(pudf1.udfvalue as int) <= 75 then '75'
				 		when cast(pudf1.udfvalue as int) > 75 and cast(pudf1.udfvalue as int) <= 150 then '150'
				 		else pudf1.udfvalue
					end
		    end
		  else 'HiSeqUnknown' || '_' || case when pudf2.udfvalue is null then 'SE' else 'PE' end || pudf1.udfvalue
		end
	when itype.name = 'Miseq' then 'MiSeq' || '_' ||
		case
			when cast(pudf1.udfvalue as int)+cast(coalesce(pudf2.udfvalue,'0') as int) <= 150 then 'UpTo150'
			else 'UpTo600'
		end
	when itype.name = 'Nextseq' then 'NextSeq' || '_' ||
		case
			when pudf4.udfvalue = 'NextSeq Mid' then 'Mid' || '_' ||
				case
					when cast(pudf1.udfvalue as int)+cast(coalesce(pudf2.udfvalue,'0') as int) <= 150 then 'UpTo150'
				 	else 'UpTo300'
				end
			else 'High' || '_' ||
				case
					when cast(pudf1.udfvalue as int)+cast(coalesce(pudf2.udfvalue,'0') as int) <= 75 then 'UpTo75'
		 			when cast(pudf1.udfvalue as int)+cast(coalesce(pudf2.udfvalue,'0') as int) > 75 and cast(pudf1.udfvalue as int)+cast(coalesce(pudf2.udfvalue,'0') as int) <= 150 then 'UpTo150'
		 			else 'UpTo300'
				end
		end
	else itype.name || '_' || case when pudf2.udfvalue is null then 'SE' else 'PE' end || pudf1.udfvalue
end || '_' || ludf1.udfvalue as ppmsservicetype,

-- col4: description SLX-ID.FCID.s_7
case when audf3.udfvalue like 'SLX-%' then audf3.udfvalue else 'SLX-Unknown' end || '.' ||
case when pudf3.udfvalue is null then container.name
     else pudf3.udfvalue
end || '.s_' ||
containerplacement.wellyposition + 1 as ppmsdescription,

-- extra columns
to_char(billing.daterun, 'YYYY-MM') as billingmonth,

audf5.udfvalue as ponumber,

audf6.udfvalue as ppmsorderid,

artifact.luid as artifactluid

-- FROM ---------------------------------------------------------------------------
FROM billing,
process
LEFT OUTER JOIN process_udf_view as pudf1 on (pudf1.processid=process.processid AND pudf1.udfname like 'Read 1 Cycle%')
LEFT OUTER JOIN process_udf_view as pudf2 on (pudf2.processid=process.processid AND pudf2.udfname like 'Read 2 Cycle%')
LEFT OUTER JOIN process_udf_view as pudf3 on (pudf3.processid=process.processid AND pudf3.udfname = 'Flow Cell ID')
LEFT OUTER JOIN process_udf_view as pudf4 on (pudf4.processid=process.processid AND pudf4.udfname = 'Chemistry'),
processtype,
installation,
instrument,
itype,
processiotracker,
artifact
LEFT OUTER JOIN artifact_udf_view as audf1 on (audf1.artifactid=artifact.artifactid AND audf1.udfname = 'Billable')
LEFT OUTER JOIN artifact_udf_view as audf3 on (audf3.artifactid=artifact.artifactid AND audf3.udfname = 'SLX Identifier')
LEFT OUTER JOIN artifact_udf_view as audf4 on (audf4.artifactid=artifact.artifactid AND audf4.udfname = 'Billing Information')
LEFT OUTER JOIN artifact_udf_view as audf5 on (audf5.artifactid=artifact.artifactid AND audf5.udfname = 'PO Number')
LEFT OUTER JOIN artifact_udf_view as audf6 on (audf6.artifactid=artifact.artifactid AND audf6.udfname = 'PPMS Order ID'),
containerplacement,
container,
artifact_sample_map,
sample,
project,
researcher,
lab
LEFT OUTER JOIN entity_udf_view as ludf1 on (ludf1.attachtoid=lab.labid and ludf1.udfname='PPMS Pricing')
LEFT OUTER JOIN entity_udf_view as ludf2 on (ludf2.attachtoid=lab.labid and ludf2.udfname='PPMS Contact Email')
LEFT OUTER JOIN address on (lab.shippingaddressid=address.addressid)

-- WHERE --------------------------------------------------------------------------
WHERE process.typeid = processtype.typeid
AND processtype.displayname like '%Run%'
AND process.installationid=installation.id
AND installation.instrumentid=instrument.instrumentid
AND instrument.typeid=itype.typeid
AND process.processid=processiotracker.processid
AND processiotracker.inputartifactid=artifact.artifactid
AND containerplacement.processartifactid=artifact.artifactid
AND containerplacement.containerid=container.containerid
AND artifact_sample_map.artifactid=artifact.artifactid
AND artifact_sample_map.processid=sample.processid
AND sample.projectid=project.projectid
AND project.researcherid=researcher.researcherid
AND researcher.labid=lab.labid
AND artifact.luid=billing.artifactluid
AND sample.name NOT LIKE 'Genomics Control%'
AND project.name != 'Controls'
AND sample.controltypeid is null
AND audf1.udfvalue = 'Bill'
AND audf6.udfvalue is null

-- ORDER BY -----------------------------------------------------------------------
ORDER BY ppmsdescription