Įdomus

M-1 (SS-47)-istorija

M-1 (SS-47)-istorija


We are searching data for your request:

Forums and discussions:
Manuals and reference books:
Data from registers:
Wait the end of the search in all databases.
Upon completion, a link will appear to access the found materials.

M-1

(SS-47: 488 t. Banglentėje), 676 t. (Subm.); 1. 196'3 "; b. 19 '; d. 11'-s. 1L k. (Naršyti), 10,5 k. (Subm.); Cpl 29; a. 1-3 ", 4-18" tt; cl M-1)

Povandeninį laivą M-1 (SS-47) 1914 m. Liepos 2 d. Padėjo Fore River Shipbuilding Co., Quincy, Mass., „Elertric Boat Co.“, Niujorkas, NY; paleistas 1915 m. rugsėjo 14 d .; remia Mis Sara Dean Roberts; užsakytas 1918 m. vasario 16 d .; Ltn. Vadovauja M. R. Pierce.

Pradėjus eksploatuoti, M-1 buvo priskirtas 2 povandeninių laivų divizijai ir buvo perkeltas į namus Niuporte, RI. Per ateinančius 3 metus ji veikė prie rytinės pakrantės, rengdama mokymus naujos kartos povandeniniams laivininkams, kurie prisidėtų prie Japonijos karinis jūrų laivynas Antrajame pasauliniame kare. Paskutinės aktyvios tarnybos metu ji buvo kontroliuojama 5 ir 3 subdiv.

1922 m. Kovo 15 d. Povandeninis laivas buvo nutrauktas Filadelfijos jūrų laivų statykloje, kitą dieną išbrauktas iš karinio jūrų laivyno sąrašo ir 1922 m. Rugsėjo 25 d.


SS-47 M-1

Viena „M“ klasės valtis buvo FY1914 sprendimo pakeisti FY1913 pirkimą dvigubo korpuso konstrukcija, kuri buvo didesnė už „K“ klasės valtis, rezultatas. Jos dizainas buvo žinomas kaip EB-39E ir ji turėjo būti eksperimentinis povandeninis laivas, dvidešimt procentų didesnis už „L“ klasės valtį, turintį beveik dvigubai didesnį plūdrumą. Rezultatas buvo labiau plaukiojantis, bet labiau perkrautas laivas su prastu balasto išdėstymu, dėl kurio ji buvo nestabili paviršiuje ar nardydama. Bandymo gylis buvo sumažintas iki 150 pėdų.

Paleistas 1914 m. Liepos mėn., M-1 buvo paleistas eksploatuoti 1918 m. Vasario mėn.

Ankstyvosios povandeninių laivų klasės, tokios kaip E, H, K, L, M, N, O ir R, žinomos kaip „kiaulių valtys“ arba „valtys“ dėl neįprastos korpuso formos ir prastų gyvenimo sąlygų, svyravo nuo 287 iki 510 tonų. Greičiausios „valtys“ pasiekė 14 mazgų maksimalų paviršiaus greitį, kai buvo naudojama dyzelinė jėgainė. Pirmojo pasaulinio karo metu JAV povandeniniai laivai pagal misiją buvo suskirstyti į dvi grupes. N ir O klasės laivai, taip pat kai kurie E tipo laivai, patruliavo Amerikos pakrantėse ir uostuose, atlikdami gynybinį vaidmenį. Kai kurios K, L, O ir E klasės valtys vykdė įžeidžiančias operacijas atviroje jūroje iš Azorų ir Bantry įlankos Airijoje. Jie palaikė sąjungininkų pastangas išlaikyti atvirus jūros kelius palei Europos pakrantę ir artėjant prie Britų salų.


Roberto Rogerso vaiduoklis, dabar einantis į karalienės šolą

Viena iš pagrindinių istoriškai baisios, bet ne mažiau linksmos AMC serijos figūrų Pasukti, kurį pavaizdavo Angusas Macfadyenas, buvo Robertas Rogersas, garsus nereguliarus, kurio dalinys puikiai pasirodė mūšyje prie sienos Prancūzijos ir Indijos karo metu.

Spalvotas mezotintas iš Roberto Rogerso Johanno Martino Willo reprezentacijos, išleistas Thomas Hart Anne S K Brown Military Collection

Žinomas kaip Vobomagonda (baltasis velnias) tarp abenakų pasienietis pagimdė tai, kas tuo metu buvo vadinama “ organizuojančiu ” karu, o jo vyrai buvo Rangers - subraižytas vienetas, kurio gretose buvo Amerikos indėnų ir laisvių.

Jo vyrai nebuvo raudonos uniformos pėstininkai, pasiruošę mūšiui.

Knötelis, Herbertas, Rogersas Rangersas, 1758. „Rodžerio reindžeris“ ir#8217 kompanija. Vasaros suknelė (1949)

Knötel, Herbert, Rogers ’ Rangers, 1758. „Ranger of Spikeman ’s Company“, žieminė suknelė (1949)

Žinoma, jo ilgalaikis karinis patarimas yra jo 28 Skyrimo taisyklės taip pat laikoma glaustesne 19 nuolatinių įsakymų.

Defacto lojalistas, kadangi 1775 m. Jis vis dar nominaliai vadovavo britų karininkų komisijai, Rogersas bandė susitarti dėl susitikimo iš Vašingtono, tačiau buvo atmestas, todėl jis 1776 m. Iškėlė „Queen ’s Rangers“ vienetą, iš kurio buvo uždirbta pinigų. Kitais metais. „Queen ’s Rangers“, kuriam tuo metu vadovavo nepaprastas majoras Jamesas Wemyssas, buvo sunaikintas „Brandywine“, kai jis buvo naudojamas kaip tradicinis pėstininkas, todėl vienetas buvo prikeltas Johno Graveso Simcoe. Po karo reindžeriai buvo išsiųsti į Kanadą ir tyliai iširo.

Kaip šiandien pažymėjo Didžiosios Britanijos armija, praradus Šiaurės Amerikos kolonijas, Didžiosios Britanijos armijai trūko miškingos sienos, kurioje būtų galima įdarbinti reindžerio padalinį, o pajėgumai nustojo egzistuoti gryna forma, ir#8221 vėliau. “Ranger ” vienetai, tokie kaip Centrinis Londono reindžeris, „Connaught Rangers“, „The Royal Irish Rangers“ ir „The Sherwood Rangers Yeomanry“, pavadinę šį vardą labiau garbingu titulu, o ne kaip specialisto reindžerio vaidmeniui skirtų pajėgų aprašymas, arba kad jie naudojo netradicinę taktiką.

Dabar naujai suformuotas reindžerių pulkas Didžiosios Britanijos armijoje ir savanoriai, surinkti iš viso pėstininkų, taip pat keturi batalionai, sujungti į jo organizaciją, 1 škotai, 2 PWRR, 2 LANCS ir 4 šautuvai ir#8212 oficialiai nešis amerikiečio Roberto Rogerso palikimą.

Tiesa, ji bus kariuomenės specialiųjų operacijų brigados dalis ir jai bus pavesta atlikti netradicinius veiksmus.

Nors naujiesiems reindžeriams galbūt ir nereikės laikytis pradinių 28 diapazono taisyklių, įskaitant vakaro paradą su „ugnimi, šešiasdešimt raundų miltelių ir rutulio bei kirvį“, jie bus savarankiški ir labai išradingi, kaip ir praeities reindžeriai.

Pasidalinti:

Kaip šitas:


BMW M1: istorija, dizainas, specifikacijos

Pagalvokite apie mėgstamų superautomobilių gamintojus, o BMW gali nepatekti į jūsų asmeninį trumpąjį sąrašą, tačiau aštuntojo dešimtmečio pabaigoje vokiečių automobilių gamintojas sukūrė vieną įdomiausių visų laikų vidutinio variklio automobilių. Gimęs iš noro pakeisti senėjančius 3.0 CSL lenktyninius automobilius, kuriuos BMW naujai įkurtas „Motorsports“ padalinys reklamavo visame pasaulyje, „M1“ turėjo būti moderniausias 4 grupės lenktyninis automobilis, tačiau homologizavimo reikalavimai reikalavo BMW 400 kelių automobilių, kad jį patvirtintų.

Tai nereiškia, kad BMW visą automobilį sukūrė pats. Tiesą sakant, galima teigti, kad M1 tikrai sukūrė italai. „Lamborghini“ buvo pasamdytas kurti kosminio rėmo važiuoklę, Gianpaolo Dallara (buvęs „Lamborghini“ darbuotojas) suprojektavo pakabą, o Giorgetto Giugiaro, neseniai įkūręs „Italdesign“, buvo atsakingas už į pleištą panašaus automobilio kėbulo modelį. Vis dėlto „M1“ plaka širdis-BMW 274 AG, 3,5 litro, DOHC šešių variklių variklis, suporuotas su penkių greičių mechanine ZF pavarų dėže. Galų gale, sukūrus pirmuosius prototipus, „Lamborghini“ finansinės bėdos sustabdė vystymąsi, todėl gamybinės važiuoklės gamybai buvo pasamdyta modelių važiuoklių gamintoja Marchesi. Kita italų įmonė pastatė kėbulus, kurie buvo prijungti prie važiuoklės Italdesign mieste. Vokietijos firma „Baur“ prižiūrėjo galutinį surinkimą Štutgarte.

1979 m. Pradžioje pagaliau pradėta gamyba, tačiau didelė lipdukų kaina ir BMW sprendimas nesiimti automobilių lenktynių plačiu mastu lėmė, kad pardavimas buvo lėtas. Galiausiai buvo pastatyti 397 M1 kelių automobiliai, kartu su 53 lenktyniniais automobiliais, kurių dauguma buvo pagaminti vieno modelio „Procar“ serijoje, kaip paramos lenktynės didesniems renginiams. „BMW M1“ gamyba buvo nutraukta 1981 m.

BMW M1 akcentai

Nors pirminis BMW tikslas su M1 buvo lenktyniauti, tai niekada neįvyko dideliu mastu. Kai kurie 4 grupės automobiliai buvo pagaminti taip, kaip buvo numatyta iš pradžių, su 470 AG varikliais, išdarinėtu interjeru ir lengvais plastikiniais langais. Deja, automobiliai buvo per sunkūs, kad būtų konkurencingi, nes buvo pagaminti iš 3000 svarų kelių automobilių. „Procar“ serija buvo „BMW Motorsports“ kūrinys, turintis turtingus vairuotojus mėgėjus ir lenktynių čempionus „Formulės 1“ lenktynėse. Nors serijoje tikriausiai nebuvo parduodama daug automobilių, „Procar M1“ atrodė fantastiškai su didžiuliais sparnais, išsipūtusiais sparneliais ir ugnį spjaudančiomis išmetamosiomis dujomis. Lenktynės taip pat nebuvo blogos.


Mūšiniai laivai [redaguoti | redaguoti šaltinį]

  • Amadeo I. klasė (1)
    • Amadeo I (1972 m.) Ispanijos geležinis dreadnought. "Rising at Ferrol" (The Times Newspaper: London England). 1972 m. Spalio 17 d
    • Aragonas klasė (3)
      • Aragonas (1881–1898)
      • Navarra (1884–1899)
      • Kastilija (1886–1898)
        (1881–1898) (1881–1884) (1885–1926) (1886–1900) (1889–1895) (1890–1989) (1891–1900) (1889–1898)
      • (1887–1898) (1887–1898)
  • Markas de la Ensenada (1894–1900)
    • Reina Regente (1888–1895) (1898–1900)
    • Lepanto (1898–1908)
      (1891–1900) (1890–1898) (1892–1898)
      (1893–1898) (1894–1898) (1895–1898)
      (1897–1898)
    • Imperatorius Carlosas V (1897–1931)
    • Rio de la Plata (1900–1931)
    • Ekstremadura (1902–1931)
    • Kardinolas Cisnerosas (1903–1905)
    • Katalonija (1908–1928)
    • Princesa de Asturias (1903–1927)
    • Reina Regente (1910–1926)
    • Reina Victoria Eugenia & gt Republica & gt Navarra (1923 ir gt1934 & gt1936-1955)
    • Blas de Lezo (1925–1932)
    • Mendezas Nuñezas (1924–1963)
      (1928–1965)
    • Principe Alfonso & gt Libertad & gt Galicia (1927 ir gt1936 & gt1939-1970)
    • Migelis de Servantesas (1930–1964)
      (1936–1975) (1936–1938)

    „M1 Garand“: istorijos gabalas

    Sgt. Nuotr. Dana Beesley | Robertas Bellas, „M1 Garand“ šarvuotojas su civilinio šaudymo programa, su šautuvu pozuoja CMP parduotuvėje per CMP nacionalines rungtynes ​​Camp Perry mieste, Ohajo valstijoje, 2018 m. Rugpjūčio 3 d. .30 kalibro pusiau automatinis ginklas buvo standartinis- išduoti šautuvą Antrojo pasaulinio karo ir Korėjos karo metu. Per pastaruosius 65 metus dauguma šautuvų buvo bent kartą perstatyti, atnaujinti, armatūros ir suremontuoti, o kai kurie iš jų yra iki šiol. (JAV jūrų pėstininkų korpuso nuotr., Serž. Dana Beesley) pamatyti mažiau | Peržiūrėti vaizdo puslapį

    PORT CLINTON, OH, JUNGTINĖS VALSTIJOS

    08.03.2018

    Pasakoja Sgt. Dana Beesley

    Jūrų pėstininkų įdarbinimo depas, Pariso sala

    Generolas George'as Pattonas, jaunesnysis, kartą sakė: „Mano nuomone, šautuvas M1 yra didžiausias kada nors sukurtas kovos įrankis“. .30 kalibro pusiau automatinis ginklas buvo standartinis šautuvas Antrojo pasaulinio karo ir Korėjos karo metu. Kariniams ir civiliams konkurentams Nacionalinėse rungtynėse Camp Perry, Ohajas, nieko panašaus nėra.

    M1 iš pradžių sukūrė Kanadoje gimęs šaunamųjų ginklų inžinierius Johnas C. Garandas. Garandas sukūrė dujomis valdomą ginklą su 0,30 colio kalibru, kuris buvo 43 colių ilgio, tačiau svėrė tik 9,5 svaro. M1 tapo pirmuoju standartinio tipo automatiniu pėstininkų šautuvu 1936 m.
    Per pastaruosius 65 metus dauguma „M1“ šautuvų buvo bent kartą perstatyti, atnaujinti, perdaryti ir pataisyti, o šiandien tik nedaugelis yra originalios būklės.

    Robertas Bellas, „M1 Garand“ šarvuotojas civilinės šaudymo programos „Camp Perry“ programoje, aptarnauja ir aprūpina vietines veteranų organizacijas ir šaudo konkurentus M1 nuo tada, kai atvyko į bazę.

    „M1 yra kaip bulvių traškučiai“, - sakė Bellas. "Jūs negalite turėti tik vieno".
    Bellas sakė, kad šautuvas prasidėjo ne kaip .30 kalibro šautuvas. Iš pradžių jis turėjo dešimties ratų klipą, o ne aštuonių ratų, tačiau buvo pakeistas prieš pat gamybą. Bellas sakė, kad pasaulyje buvo pagaminta tik šeši milijonai M1 šautuvų.

    „M1 Garand“ turi du variantus, kuriuos JAV kariuomenė naudoja nuo 1944 m. Per Antrąjį pasaulinį karą „Springfield“ šaunamieji ginklai sukūrė „M1C“ snaiperio variantą, prie kurio buvo pritvirtintas taikiklis. 1944 m. Birželio mėn. JAV kariuomenė jį priėmė kaip standartinį snaiperinį šautuvą, kuris pakeis M19034.

    Buvo problemų su M1C, nes laikiklių montavimo procedūra sumažino tikslumą, iškreipdama imtuvą. Dėl to buvo sukurtas M1D, kurio vietoje statinio buvo pritvirtintas laikiklis, o ne imtuvas. Jūrų pėstininkai 1951 metais priėmė M1C kaip savo oficialų snaiperinį šautuvą.

    Bellas sakė, kad iki šiol kariuomenė pagal serijos numerį gali pasakyti, kuris šautuvas anksčiau buvo M1C. M1D buvo populiaresni ir tikslesni už M1C variantą. Bellas sakė, kad abiejų ginklų problema buvo ta, kad taikymo sritis buvo maždaug colio aukščio ir nuo centro.

    Atsitiktinis purvas ir nešvarumai nesumažins ginklo šaudymo galios, nes jį išmontuoti paprasta, todėl idealiai tinka lauke, sakė jis. Šaulys gali lengvai pašalinti gaiduko grupę ir ją pakeisti, nes ji buvo išardyta kulkos smaigaliu.

    Skirtingas „ping“ garsas, sklindantis iš „M1 Garand“, taip pat leidžia jį atpažinti diapazone. Garsas sklinda iš spaustuko, atsitrenkiančio į imtuvo nugarą, kai pasekėjas jį išmeta iš ginklo. Bellas kalbėjo apie mitą, kad dėl pingo triukšmo kariai tapo pastebimi priešui mūšio lauke.

    „Girdėjau, kaip žmonės sako, kad vokiečiai laukė pingo, kol nepuls“, - sakė Bellas. „Aš kalbėjau su vokiečių kareiviais ir pora„ Panzer “vadų ir paklausiau jų apie pingą, ir jie visi sakė tą patį:„ į mus šaudo, mūsų klausa jau nėra tokia puiki. Mes to klausymo neklausėme “.

    „Marine Corps Recruit Depot Parris Island Shooting Team“ rugpjūčio 4 d. Varžysis „M1 Garand“ rungtynėse per nacionalines rungtynes. Komandos narys Cpl. Trevoras Keithas sakė, kad šautuvo istorija yra tai, kas paskatino jį susidomėti šaudymu.

    „Man patinka„ M1 Garand “, nes tai yra istorijos dalis“, - sakė Keithas. „Jis laimėjo pasaulinį karą, kai jį nušauni, gali pajusti istoriją. Kai pirmą kartą jį nušoviau, maniau, kad jį bus sunku suvaldyti, tačiau ginklo svoris tai kompensavo. Jie yra labai tikslūs ir nuostabu, kad jie gali neatsilikti nuo šių dienų varžybų, nors jiems jau daugiau nei 70 metų.

    Per kelis dešimtmečius Bellas dirbo su įvairiais ginklais, tačiau mano, kad „M1 Garand“ išsiskiria puikiu ginklu.

    „Nebent tikrai susipainiosite, galite statyti už juos savo gyvenimą, ir tai padarė daugelis vaikinų“.


    M-1 (SS-47)-istorija

    8 bendraautoriai

    Vartotojai, prisidėję prie šio failo

    & lt? php
    /**
    * SimpleXLSX php klasė v0.8.23
    * „MS Excel 2007“ darbaknygių skaitytuvas
    *
    * Autorių teisės (c) 2012–2021 m. „SimpleXLSX“
    *
    * @kategorija „SimpleXLSX“
    * @pakuotė SimpleXLSX
    * @copyright Copyright (c) 2012 - 2020 SimpleXLSX (https://github.com/shuchkin/simplexlsx/)
    * @license MIT
    * @versija 0.8.23
    */
    /** Pavyzdžiai
    *
    * 1 pavyzdys:
    * jei ($ xlsx = SimpleXLSX :: parse ('book.xlsx ')) <
    * print_r ($ xlsx- & gtrows ())
    *> kitaip <
    * echo SimpleXLSX :: parseError ()
    * >
    *
    * 2 pavyzdys: html lentelė
    * jei ($ xlsx = SimpleXLSX :: parse ('book.xlsx ')) <
    * echo $ xlsx- & gttoHTML ()
    *> kitaip <
    * echo SimpleXLSX :: parseError ()
    * >
    *
    * 3 pavyzdys: rowsEx
    * $ xlsx = SimpleXLSX :: parse ('book.xlsx ')
    * print_r ($ xlsx- & gtrowsEx ())
    *
    * 4 pavyzdys: pasirinkite darbalapį
    * $ xlsx = SimpleXLSX :: parse ('book.xlsx ')
    * print_r ($ xlsx- & gtrows (1)) // antrasis darbalapis
    *
    * 5 pavyzdys: ID ir darbalapio pavadinimai
    * $ xlsx = SimpleXLSX :: parse ('book.xlsx ')
    * print_r ($ xlsx- & gtsheetNames ()) // masyvas (0 = & gt Ƈ lapas ', 1 = & gt 'Katalogas ')
    *
    * 6 pavyzdys: gaukite lapo pavadinimą pagal indeksą
    * $ xlsx = SimpleXLSX :: parse ('book.xlsx ')
    * echo 'Sheet Name 2 = '. $ xlsx- & gtsheetName (1)
    *
    * 7 pavyzdys: „getCell“ (labai lėtas)
    * echo $ xlsx- & gtgetCell (1, 'D12 ') // skaito D12 langelį iš antro lapo
    *
    * 8 pavyzdys: skaityti duomenis
    * jei ($ xlsx = SimpleXLSX :: parseData (file_get_contents ('http: //www.example.com/example.xlsx'))] <
    * $ dim = $ xlsx- & gtdimension (1)
    * $ num_cols = $ dim [0]
    * $ num_rows = $ dim [1]
    * echo $ xlsx- & gtsheetName (1). ': '. $ num_cols. 'x '. $ num_rows
    *> kitaip <
    * echo SimpleXLSX :: parseError ()
    * >
    *
    * 9 pavyzdys: senas stilius
    * $ xlsx = naujas SimpleXLSX ('book.xlsx ')
    * jei ($ xlsx- & gtsuccess ()) <
    * print_r ($ xlsx- & gtrows ())
    *> kitaip <
    * aido ir#39xlsx klaida: '. $ xlsx- & gterror ()
    * >
    */
    /** @noinspection PhpUndefinedFieldInspection*/
    /** @noinspection PhpComposerExtensionStubsInspection*/
    /** @noinspection MultiAssignmentUsageInspection*/
    klasė SimpleXLSX <
    // Nepašalinkite šios eilutės! Sukūrė Sergejus Shuchkinas [email protected]
    public static $ CF = [// Ląstelių formatai
    0 = & gt ' Bendrieji ',
    1 = & gt Ɔ ',
    2 = & gt Ɔ.00 ',
    3 = & gt '#, ## 0 ',
    4 = & gt '#, ## 0.00 ',
    9 = & gt Ɔ%',
    10 = & gt Ɔ,00%',
    11 = & gt Ɔ.00E+00 ir#39,
    12 = & gt '#?/? ',
    13 = & gt '#??/?? ',
    14 = & gt 'mm-dd-yy ',
    15 = & gt 'd-mmm-yy ',
    16 = & gt 'd-mmm ',
    17 = & gt 'mmm-yy ',
    18 = & gt 'h: mm AM/PM ',
    19 = & gt 'h: mm: ss AM/PM ',
    20 = & gt 'h: mm ',
    21 = & gt 'h: mm: ss ',
    22 = & gt 'm/d/yy h: mm ',
    37 = & gt '#, ## 0 (#, ## 0) ',
    38 = & gt '#, ## 0 [raudona] (#, ## 0) ',
    39 = & gt '#, ## 0.00 (#, ## 0.00) ',
    40 = & gt '#, ## 0.00 [raudona] (#, ## 0.00) ',
    44 = & gt ' _ (& quotquot*#, ## 0.00 _) _ (& quotquot* (#, ## 0.00 0.00) _ (& quotquot* & quot- & quot ?? _) _ (@_) ',
    45 = & gt 'mm: ss ',
    46 = & gt ' [h]: mm: ss ',
    47 = & gt 'mmss.0 ',
    48 = & gt ' ## 0.0E+0 ',
    49 = & gt &#[email protected]',
    27 = & gt ' [$-404] e/m/d ',
    30 = & gt ' m/d/yy ',
    36 = & gt ' [$-404] e/m/d ',
    50 = & gt ' [$-404] e/m/d ',
    57 = & gt ' [$-404] e/m/d ',
    59 = & gt 't0 ',
    60 = & gt 't0.00 ',
    61 = & gt 't#, ## 0 ',
    62 = & gt 't#, ## 0.00 ',
    67 = & gt 't0%',
    68 = & gt 't0,00%',
    69 = & gt 't#?/? ',
    70 = & gt 't#??/?? ',
    ]
    public $ cellFormats = []
    public $ datetimeFormat = 'Y-m-d H: i: s '
    viešas $ derinimas
    / * @var SimpleXMLElement [] $ sheet */
    apsaugotų $ lakštų
    apsaugotas $ sheetNames = []
    apsaugotas $ sheetFiles = []
    // schema
    saugomi $ stiliai
    apsaugotas $ hipersaitus
    / * @var masyvas [] $ paketas */
    apsaugotas $ paketas
    apsaugota $ sharedstrings
    apsaugota $ date1904 = 0
    /*
    privatus $ date_formats = array (
    0xe = & gt & quotd/m/Y & quot;
    0xf = & gt & quotd-M-Y & quot;
    0x10 = & gt & quotd-M & quot;
    0x11 = & gt & quot; M-Y & quot;
    0x12 = & gt & quoth: i a & quot,
    0x13 = & gt & quoth: i: s a & quot,
    0x14 = & gt & quot; H: i & quot;
    0x15 = & gt & quot; H: i: s & quot;
    0x16 = & gt & quotd/m/Y H: i & quot;
    0x2d = & gt & quoti: s & quot;
    0x2e = & gt & quot; H: i: s & quot;
    0x2f = & gt & quoti: s.S & quot
    )
    privatus $ number_formats = array (
    0x1 = & gt & quot;%1.0f & quot; // & quot0 & quot
    0x2 = & gt & quot;%1.2f & quot;, & quot; 0,00 & quot;
    0x3 = & gt & quot;%1.0f & quot;, // & quot#, ## 0 & quot,
    0x4 = & gt "%1.2f", //"#,##0.00",
    0x5 = & gt & quot;%1.0f & quot;, & quot; $#, ## 0 ($#, ## 0) & quot;
    0x6 = & gt ' $%1.0f ', // & quot $#, ## 0 ($#, ## 0) & quot,
    0x7 = & gt ' $%1.2f ', //"$#,##0.00($#,##0.00)",
    0x8 = & gt ' $%1.2f ', //"$#,##0.00($#,##0.00)",
    0x9 = & gt '%1.0f %% ', // & quot0%& quot
    0xa = & gt '%1.2f %% ', //"0.00%"
    0xb = & gt '%1.2f ', //"0.00E00",
    0x25 = & gt '%1.0f ', // & quot#, ## 0 (#, ## 0) & quot,
    0x26 = & gt '%1.0f ', // & quot#, ## 0 (#, ## 0) & quot,
    0x27 = & gt '%1.2f ', //"#,##0.00(#,##0.00)",
    0x28 = & gt '%1.2f ', //"#,##0.00(#,##0.00)",
    0x29 = & gt '%1.0f ', // & quot#, ## 0 (#, ## 0) & quot,
    0x2a = & gt ' $%1.0f ', // & quot $#, ## 0 ($#, ## 0) & quot,
    0x2b = & gt '%1.2f ', //"#,##0.00(#,##0.00)",
    0x2c = & gt ' $%1.2f ', //"$#,##0.00($#,##0.00)",
    0x30 = & gt '%1.0f ') //"##0.0E0"
    // >>>
    */
    apsaugota $ errno = 0
    apsaugota $ error = false
    viešoji funkcija __construct ($ filename = null, $ is_data = null, $ debug = null) <
    jei ($ debug! == null) <
    $ this -& gt debug = $ debug
    >
    $ this -& gt paketas = [
    'filename ' = & gt ' ',
    'mtime ' = & gt 0,
    'dydis ' = & gt 0,
    ' komentaras ' = & gt ' ',
    'entries ' = & gt []
    ]
    if ($ filename & amp & amp $ this -& gt _unzip ($ failo pavadinimas, $ is_data)) <
    $ tai -& gt _parse ()
    >
    >
    public static function parseFile ($ failo pavadinimas, $ debug = false) <
    return self :: parse ($ failo vardas, klaidinga, $ derinimas)
    >
    viešoji statinė funkcija parseData ($ data, $ debug = false) <
    return self :: analizuoti ($ data, true, $ debug)
    >
    viešoji statinė funkcija analizė ($ failo pavadinimas, $ is_data = false, $ debug = false) <
    $ xlsx = naujas aš ()
    $ xlsx -& gt debug = $ debug
    jei ($ xlsx -& gt _unzip ($ failo pavadinimas, $ is_data)) <
    $ xlsx -& gt _parse ()
    >
    jei ($ xlsx -& gt success ()) <
    grąžinti $ xlsx
    >
    self :: parseError ($ xlsx -& gt klaida ())
    self :: parseErrno ($ xlsx -& gt errno ())
    grąžinti klaidingai
    >
    public static function parseError ($ set = false) <
    statinė $ klaida = klaidinga
    grąžinti $ rinkinį? $ error = $ set: $ error
    >
    viešoji statinė funkcija parseErrno ($ set = false) <
    static $ errno = klaidinga
    grąžinti $ rinkinį? $ errno = $ nustatytas: $ errno
    >
    apsaugota funkcija _unzip ($ failo pavadinimas, $ is_data = false) <
    jei ($ is_data) <
    $ this -& gt package ['filename '] = 'default.xlsx '
    $ this -& gt paketas ['mtime '] = laikas ()
    $ this -& gt package ['size '] = $ this -& gt _strlen ($ failo pavadinimas)
    $ vZ = $ failo pavadinimas
    > kitaip <
    if (! is_readable ($ filename)) <
    $ this -& gt klaida (1, 'failas nerastas '. $ failo pavadinimas)
    grąžinti klaidingai
    >
    // Informacija apie pakuotę
    $ this -& gt package ['filename '] = $ failo pavadinimas
    $ this -& gt package ['mtime '] = filemtime ($ failo pavadinimas)
    $ this -& gt package ['size '] = failo dydis ($ filename)
    // Skaityti failą
    $ vZ = file_get_contents ($ failo pavadinimas)
    >
    // Iškirpti centrinio katalogo pabaigą
    /* $ aE = sprogti (& quot; x50 x4b x05 x06 & quot, $ vZ)
    jei (skaičius ($ aE) == 1) <
    $ this- & gterror ('nežinomas formatas ')
    grąžinti klaidingai
    >
    */
    // Sprogti iki kiekvienos dalies
    $ aE = sprogti (& quot; x50 x4b x03 x04 & quot, $ vZ)
    masyvo_paslinkimas ($ aE)
    $ aEL = skaičius ($ aE)
    jei ($ aEL === 0) <
    $ this -& gt klaida (2, 'Nežinomas archyvo formatas ')
    grąžinti klaidingai
    >
    // Ieškoti centrinio katalogo pabaigos įrašo
    $ last = $ aE [$ aEL - 1]
    $ last = sprogti (& quot; x50 x4b x05 x06 & quot; $ last)
    jei (skaičiuok ($ last)! == 2) <
    $ this -& gt klaida (2, 'Nežinomas archyvo formatas ')
    grąžinti klaidingai
    >
    // Ieškoti centriniame kataloge
    $ last = sprogti (& quot; x50 x4b x01 x02 & quot, $ last [0])
    if (skaičiuoti ($ last) & lt 2) <
    $ this -& gt klaida (2, 'Nežinomas archyvo formatas ')
    grąžinti klaidingai
    >
    $ aE [$ aEL - 1] = $ paskutinis [0]
    // Peržiūrėkite įrašus
    foreach ($ aE kaip $ vZ) <
    $ aI = []
    $ aI ['E '] = 0
    $ aI ['EM '] = ' '
    // Vietinės failo antraštės informacijos gavimas
    // $ aP = išpakuokite ('v1VN/v1GPF/v1CM/v1FT/v1FD/V1CRC/V1CS/V1UCS/v1FNL ', $ vZ)
    $ aP = išpakuokite ('v1VN/v1GPF/v1CM/v1FT/v1FD/V1CRC/V1CS/V1UCS/v1FNL/v1EFL ', $ vZ)
    // Patikrinkite, ar duomenys yra užšifruoti
    // $ bE = ($ aP ['GPF '] & amp & amp 0x0001)? TIESA: NETIESA
    $ bE = klaidinga
    $ nF = $ aP ['FNL ']
    $ mF = $ aP ['EFL ']
    // Specialus atvejis: reikšmių blokas po suglaudintų duomenų
    jei ($ aP ['GPF '] & amp 0x0008) <
    $ aP1 = išpakuokite ('V1CRC/V1CS/V1UCS ', $ tai - & gt _substr ($ vZ, - 12))
    $ aP ['CRC '] = $ aP1 ['CRC ']
    $ aP ['CS '] = $ aP1 ['CS ']
    $ aP ['UCS '] = $ aP1 ['UCS ']
    // 2013-08-10
    $ vZ = $ tai - & gt _substr ($ vZ, 0, - 12)
    if ($ this - & gt _substr ($ vZ, - 4) === & quot x50 x4b x07 x08 & quot) <
    $ vZ = $ tai - & gt _substr ($ vZ, 0, - 4)
    >
    >
    // Gaunamas išsaugotas failo pavadinimas
    $ aI ['N '] = $ tai -& gt _substr ($ vZ, 26, $ nF)
    $ aI ['N '] = str_replace (' ', '/', $ aI ['N '])
    if ($ this - & gt _substr ($ aI ['N '], - 1) === '/') <
    // yra katalogo įrašas - bus praleistas
    Tęsti
    >
    // Sutrumpinkite visą failo pavadinimą keliu ir failo pavadinimu
    $ aI ['P '] = dirname ($ aI ['N '])
    $ aI ['P '] = ($ aI ['P '] === '. ')? ' ': $ aI ['P ']
    $ aI ['N '] = bazinis pavadinimas ($ aI ['N '])
    $ vZ = $ tai -& gt _substr ($ vZ, 26 + $ nF + $ mF)
    if ($ this -& gt _strlen ($ vZ)! == (int) $ aP ['CS '])
    $ aI ['E '] = 1
    $ aI ['EM '] = 'Suspaustas dydis nėra lygus antraštės informacijos vertei. '
    > elseif ($ bE) <
    $ aI ['E '] = 5
    $ aI ['EM '] = 'Failas yra užšifruotas, o tai nepalaikoma šioje klasėje. '
    > kitaip <
    jungiklis ($ aP ['CM ']) <
    0 atvejis: // saugomas
    // Čia nėra ką veikti, failas yra plokščias.
    pertrauka
    8 atvejis: // ištuštintas
    $ vZ = gzinflate ($ vZ)
    pertrauka
    12 atvejis: // BZIP2
    jei (plėtinio įkeltas ('bz2 ')) <
    /** @noinspection PhpComposerExtensionStubsInspection*/
    $ vZ = bzdecompress ($ vZ)
    > kitaip <
    $ aI ['E '] = 7
    $ aI ['EM '] = 'PHP BZIP2 plėtinys nepasiekiamas. '
    >
    pertrauka
    numatytas :
    $ aI ['E '] = 6
    $ aI ['EM '] = & quot; De-/suspaudimo metodas <$ aP ['CM ']> nepalaikomas. & quot
    >
    jei (! $ aI ['E ']) <
    jei ($ vZ === false) <
    $ aI ['E '] = 2
    $ aI ['EM '] = ' Nepavyko išspausti duomenų. '
    > elseif ($ tai -& gt _strlen ($ vZ)! == (int) $ aP ['UCS ']) <
    $ aI ['E '] = 3
    $ aI ['EM '] = 'Nespaustas dydis nėra lygus antraštės informacijos vertei. '
    > elseif (crc32 ($ vZ)! == $ aP ['CRC ']) <
    $ aI ['E '] = 4
    $ aI ['EM '] = ' CRC32 kontrolinė suma nėra lygi antraštės informacijos vertei. '
    >
    >
    >
    $ aI ['D '] = $ vZ
    // DOS į UNIX laiko žymą
    $ aI ['T '] = mktime (($ aP ['FT '] & amp 0xf800) & gt & gt 11,
    ($ aP ['FT '] & amp; 0x07e0) & gt & gt 5,
    ($ aP ['FT '] ir 0x001f) & lt & lt 1,
    ($ aP ['FD '] & amp 0x01e0) & gt & gt 5,
    $ aP ['FD '] ir 0x001f,
    (($ aP ['FD '] & amp 0xfe00) & gt & gt 9) + 1980)
    // $ this- & gtEntries [] = & ampnew SimpleUnzipEntry ($ aI)
    $ this -& gt paketas ['entries '] [] = [
    'data ' = & gt $ aI ['D '],
    ' klaida ' = & gt $ aI ['E '],
    'error_msg ' = & gt $ aI ['EM '],
    'pavadinimas ' = & gt $ aI ['N '],
    'path ' = & gt $ aI ['P '],
    'time ' = & gt $ aI ['T ']
    ]
    > // pabaiga kiekvienam įrašui
    grįžti tiesa
    >
    // lapų numeracija: 1,2,3.
    viešosios funkcijos klaida ($ num = null, $ str = null) <
    jei ($ num) <
    $ this -& gt errno = $ num
    $ this -& gt klaida = $ str
    jei ($ this -& gt debug) <
    trigger_error (__CLASS__. ': '. $ this -& gt klaida, E_USER_WARNING)
    >
    >
    grąžinti $ this -& gt klaida
    >
    viešoji funkcija errno () <
    grąžinti $ this -& gt errno
    >
    apsaugota funkcija _parse () <
    // Dokumento duomenų laikikliai
    $ this -& gt sharedstrings = []
    $ this -& gt sheet = []
    // $ this- & gtstyles = array ()
    // Skaityti santykius ir ieškoti officeDocument
    jei ($ santykiai = $ tai -& gt getEntryXML ('_rels/.rels ')) <
    foreach ($ santykiai -& gt Santykiai kaip $ rel) <
    $ rel_type = basename (trim ((string) $ rel ['Type '])) // officeDocument
    $ rel_target = $ this -& gt _getTarget (' ', (string) $ rel ['Target ']) // /xl/workbook.xml arba xl/workbook.xml
    if ($ rel_type === 'officeDocument ' & amp & amp $ workbook = $ this -& gt getEntryXML ($ rel_target)) <
    $ index_rId = [] // [0 = & gt rId1]
    $ indeksas = 0
    foreach ($ darbo knyga -& gt lapai -& gt lapas kaip $ s) <
    $ this -& gt sheetNames [$ index] = (string) $ s ['name ']
    $ index_rId [$ index] = (eilutė) $ s ['id ']
    $ indeksas ++
    >
    if ((int) $ workbook -& gt workbookPr ['date1904 '] === 1) <
    $ this -& gt date1904 = 1
    >
    if ($ workbookRelations = $ this -& gt getEntryXML (dirname ($ rel_target). '/_rels/workbook.xml.rels ')) <
    // Darbo knygos ir ištraukos lapų kilpos ryšiai.
    foreach ($ workbookRelations -& gt Relationship as $ workbookRelation) <
    $ wrel_type = bazinis pavadinimas (trim ((string) $ workbookRelation ['Type ']))
    $ wrel_path = $ this -& gt _getTarget (dirname ($ rel_target), (string) $ workbookRelation ['Target '])
    jei (! $ this -& gt entryExists ($ wrel_path)) <
    Tęsti
    >
    if ($ wrel_type === ' worksheet ')
    jei ($ sheet = $ this -& gt getEntryXML ($ wrel_path)) <
    $ index = array_search ((string) $ workbookRelation ['Id '], $ index_rId, false)
    $ this -& gt sheet [$ index] = $ sheet
    $ this -& gt sheetFiles [$ index] = $ wrel_path
    >
    > elseif ($ wrel_type === 'sharedStrings ') <
    jei ($ sharedStrings = $ this -& gt getEntryXML ($ wrel_path)) <
    foreach ($ sharedStrings -& gt si as $ val) <
    jei (isset ($ val -& gt t)) <
    $ this -& gt sharedstrings [] = (eilutė) $ val -& gt t
    > elseif (isset ($ val -& gt r)) <
    $ this -& gt sharedstrings [] = $ tai -& gt _parseRichText ($ val)
    >
    >
    >
    > elseif ($ wrel_type === 'styles ') <
    $ this -& gt styles = $ this -& gt getEntryXML ($ wrel_path)
    $ nf = []
    if ($ this -& gt stiliai -& gt numFmts -& gt numFmt! == null) <
    foreach ($ this -& gt stiliai -& gt numFmts -& gt numFmt kaip $ v) <
    $ nf [(int) $ v ['numFmtId ']] = (eilutė) $ v ['formatCode ']
    >
    >
    if ($ this -& gt stiliai -& gt cellXfs -& gt xf! == null) <
    foreach ($ this -& gt stiliai -& gt cellXfs -& gt xf kaip $ v) <
    $ v = (masyvas) $ v -& gt atributai ()
    $ v ['format '] = ' '
    if (isset ($ v [&#[email protected] '] ['numFmtId '])) <
    $ v = $ v [&#[email protected] ']
    $ fid = (int) $ v ['numFmtId ']
    // formatų prioritetas
    jei (isset ($ nf [$ fid]))) <
    $ v ['format '] = $ nf [$ fid]
    > elseif (isset (self :: $ CF [$ fid])) <
    $ v ['format '] = save :: $ CF [$ fid]
    >
    >
    $ this -& gt cellFormats [] = $ v
    >
    >
    >
    >
    pertrauka
    >
    >
    >
    >
    jei (suskaičiuokite ($ this -& gt sheet)) <
    // Rūšiuoti lapus
    ksort ($ tai -& gt lapai)
    grįžti tiesa
    >
    grąžinti klaidingai
    >
    /*
    * @param string $ name Failo pavadinimas archyve
    * @grįžti SimpleXMLElement | bool
    */
    viešoji funkcija getEntryXML ($ pavadinimas) <
    jei ($ entry_xml = $ this -& gt getEntryData ($ name)) <
    $ entry_xml = apdaila ($ entry_xml)
    // nešvarus pašalinti vardų srities priešdėlius ir tuščias eilutes
    $ entry_xml = preg_replace ('/xmlns [^=]*= & quot [^& quot]*& quot/i ', ' ', $ entry_xml) // pašalinti vardų sritis
    $ entry_xml = preg_replace ('/[a-zA-Z0-9]+: ([a-zA-Z0-9]+= & quot [^& quot]+& quot)/', ' $ 1 $ 2 ', $ entry_xml) // pašalinti vardų srities atr
    $ entry_xml = preg_replace ('/& lt [a-zA-Z0-9]+: ([^& gt]+) & gt/', ' & lt $ 1 & gt ', $ entry_xml) // atvertas vardų tarpas žymes
    $ entry_xml = preg_replace ('/& lt /[a-zA-Z0-9]+: ([^& gt]+) & gt/', ' & lt/$ 1 & gt ', $ entry_xml) // pataisyti uždarytas vardines žymes
    // if ($ this- & gtskipEmptyRows & amp & amp strpos ($ name, '/sheet ')) <
    if (strpos ($ name, '/sheet '))
    $ entry_xml = preg_replace ('/& ltrow [^& gt]+& gt s*(& ltc [^/]+/& gt s*)+& lt /row & gt/', ' ', $ entry_xml, - 1, $ cnt) // pašalinkite tuščias eilutes
    $ entry_xml = preg_replace ('/& ltrow [^/& gt]*/& gt/', ' ', $ entry_xml, - 1, $ cnt2)
    $ entry_xml = preg_replace ('/& ltrow [^& gt]*& gt & lt /row & gt/', ' ', $ entry_xml, - 1, $ cnt3)
    jei ($ cnt || $ cnt2 || $ cnt3) <
    $ entry_xml = preg_replace ('/& ltdimension [^/]+/& gt/', ' ', $ entry_xml)
    >
    // file_put_contents (bazinis pavadinimas ($ name), $ entry_xml) // @komentuoti.
    >
    // XML išorinio subjekto (XXE) prevencija, libxml_disable_entity_loader nebenaudojama PHP 8
    jei (LIBXML_VERSION & lt 20900) <
    $ _old = libxml_disable_entity_loader ()
    >
    $ entry_xmlobj = simplexml_load_string ($ entry_xml)
    jei (LIBXML_VERSION & lt 20900) <
    /** @noinspection PhpUndefinedVariableInspection*/
    libxml_disable_entity_loader ($ _old)
    >
    jei ($ entry_xmlobj) <
    return $ entry_xmlobj
    >
    $ e = libxml_get_last_error ()
    jei ($ e) <
    $ this -& gt klaida (3, 'XX -entry '. $ name. ' parserio klaida '. $ e -& gt message. ' line '. $ e -& gt line)
    >
    > kitaip <
    $ this -& gt klaida (4, 'XML įrašas nerastas '. $ pavadinimas)
    >
    grąžinti klaidingai
    >
    viešoji funkcija getEntryData ($ pavadinimas) <
    $ name = ltrim (str_replace (' ', '/', $ name), '/')
    $ dir = $ tai -& gt _strtoupper (dirname ($ name))
    $ name = $ this -& gt _strtoupper (basename ($ name))
    foreach ($ this -& gt package ['entries '] kaip $ įrašas) <
    if ($ this -& gt _strtoupper ($ entry ['path ']) === $ dir & amp & amp $ this -& gt _strtoupper ($ entry ['name ']) === $ pavadinimas] <
    grąžinti $ įrašą ['data ']
    >
    >
    $ this -& gt klaida (5, 'Įrašas nerastas '. ($ dir? $ dir. '/': ' '). $ pavadinimas)
    grąžinti klaidingai
    >
    viešosios funkcijos įrašasExists ($ name)
    $ dir = $ this -& gt _strtoupper (dirname ($ name))
    $ name = $ this -& gt _strtoupper (basename ($ name))
    foreach ($ this -& gt package ['entries '] kaip $ įrašas) <
    if ( $ this -> _strtoupper ( $ entry [ 'path' ] ) === $ dir && $ this -> _strtoupper ( $ entry [ 'name' ] ) === $ name ) <
    return true
    >
    >
    return false
    >
    public function success () <
    return ! $ this -> error
    >
    public function rows ( $ worksheetIndex = 0 ) <
    if ( ( $ ws = $ this -> worksheet ( $ worksheetIndex ) ) === false ) <
    return false
    >
    $ dim = $ this -> dimension ( $ worksheetIndex )
    $ numCols = $ dim [ 0 ]
    $ numRows = $ dim [ 1 ]
    $ emptyRow = []
    for ( $ i = 0 $ i < $ numCols $ i ++ ) <
    $ emptyRow [] = ''
    >
    $ rows = []
    for ( $ i = 0 $ i < $ numRows $ i ++ ) <
    $ rows [] = $ emptyRow
    >
    $ curR = 0
    /* @var SimpleXMLElement $ws */
    foreach ( $ ws -> sheetData -> row as $ row ) <
    $ curC = 0
    foreach ( $ row -> c as $ c ) <
    // detect skipped cols
    $ idx = $ this -> getIndex ( ( string ) $ c [ 'r' ] )
    $ x = $ idx [ 0 ]
    $ y = $ idx [ 1 ]
    if ( $ x > - 1 ) <
    $ curC = $ x
    $ curR = $ y
    >
    $ rows [ $ curR ][ $ curC ] = $ this -> value ( $ c )
    $ curC ++
    >
    $ curR ++
    >
    return $ rows
    >
    // https://github.com/shuchkin/simplexlsx#gets-extend-cell-info-by--rowsex
    public function rowsEx ( $ worksheetIndex = 0 ) <
    if ( ( $ ws = $ this -> worksheet ( $ worksheetIndex ) ) === false ) <
    return false
    >
    $ rows = []
    $ dim = $ this -> dimension ( $ worksheetIndex )
    $ numCols = $ dim [ 0 ]
    $ numRows = $ dim [ 1 ]
    for ( $ y = 0 $ y < $ numRows $ y ++ ) <
    for ( $ x = 0 $ x < $ numCols $ x ++ ) <
    // 0.6.8
    $ c = ''
    for ( $ k = $ x $ k >= 0 $ k = ( int ) ( $ k / 26 ) - 1 ) <
    $ c = chr ( $ k % 26 + 65 ) . $ c
    >
    $ rows [ $ y ][ $ x ] = [
    'type' => '' ,
    'name' => $ c . ( $ y + 1 ),
    'value' => '' ,
    'href' => '' ,
    'f' => '' ,
    'format' => '' ,
    'r' => $ y
    ]
    >
    >
    $ curR = 0
    /* @var SimpleXMLElement $ws */
    foreach ( $ ws -> sheetData -> row as $ row ) <
    $ r_idx = ( int ) $ row [ 'r' ]
    $ curC = 0
    foreach ( $ row -> c as $ c ) <
    $ r = ( string ) $ c [ 'r' ]
    $ t = ( string ) $ c [ 't' ]
    $ s = ( int ) $ c [ 's' ]
    $ idx = $ this -> getIndex ( $ r )
    $ x = $ idx [ 0 ]
    $ y = $ idx [ 1 ]
    if ( $ x > - 1 ) <
    $ curC = $ x
    $ curR = $ y
    >
    if ( $ s > 0 && isset ( $ this -> cellFormats [ $ s ] ) ) <
    $ format = $ this -> cellFormats [ $ s ][ 'format' ]
    > else <
    $ format = ''
    >
    $ rows [ $ curR ][ $ curC ] = [
    'type' => $ t ,
    'name' => ( string ) $ c [ 'r' ],
    'value' => $ this -> value ( $ c ),
    'href' => $ this -> href ( $ worksheetIndex , $ c ),
    'f' => ( string ) $ c -> f ,
    'format' => $ format ,
    'r' => $ r_idx
    ]
    $ curC ++
    >
    $ curR ++
    >
    return $ rows
    >
    public function toHTML ( $ worksheetIndex = 0 ) <
    $ s = '<table >
    foreach ( $ this -> rows ( $ worksheetIndex ) as $ r ) <
    $ s .= '<tr>'
    foreach ( $ r as $ c ) <
    $ s .= '<td nowrap>' . ( $ c === '' ? '&nbsp' : htmlspecialchars ( $ c , ENT_QUOTES ) ) . '</td>'
    >
    $ s .= "</tr> "
    >
    $ s .= '</table>'
    return $ s
    >
    public function worksheet ( $ worksheetIndex = 0 ) <
    if ( isset ( $ this -> sheets [ $ worksheetIndex ] ) ) <
    $ ws = $ this -> sheets [ $ worksheetIndex ]
    if ( ! isset ( $ this -> hyperlinks [ $ worksheetIndex ]) && isset ( $ ws -> hyperlinks ) ) <
    $ this -> hyperlinks [ $ worksheetIndex ] = []
    $ sheet_rels = str_replace ( 'worksheets' , 'worksheets/_rels' , $ this -> sheetFiles [ $ worksheetIndex ]). '.rels'
    $ link_ids = []
    if ( $ rels = $ this -> getEntryXML ( $ sheet_rels ) ) <
    // hyperlink
    // $rel_base = dirname( $sheet_rels )
    foreach ( $ rels -> Relationship as $ rel ) <
    $ rel_type = basename ( trim ( ( string ) $ rel [ 'Type' ] ) )
    if ( $ rel_type === 'hyperlink' ) <
    $ rel_id = ( string ) $ rel [ 'Id' ]
    $ rel_target = ( string ) $ rel [ 'Target' ]
    $ link_ids [ $ rel_id ] = $ rel_target
    >
    >
    >
    foreach ( $ ws -> hyperlinks -> hyperlink as $ hyperlink ) <
    $ ref = ( string ) $ hyperlink [ 'ref' ]
    if ( $ this -> _strpos ( $ ref , ':' ) > 0 ) < // A1:A8 -> A1
    $ ref = explode ( ':' , $ ref )
    $ ref = $ ref [ 0 ]
    >
    // $this->hyperlinks[ $worksheetIndex ][ $ref ] = (string) $hyperlink['display']
    $ loc = ( string ) $ hyperlink [ 'location' ]
    $ id = ( string ) $ hyperlink [ 'id' ]
    if ( $ id ) <
    $ href = $ link_ids [ $ id ] . ( $ loc ? '#' . $ loc : '' )
    > else <
    $ href = $ loc
    >
    $ this -> hyperlinks [ $ worksheetIndex ][ $ ref ] = $ href
    >
    >
    return $ ws
    >
    $ this -> error ( 6 , 'Worksheet not found ' . $ worksheetIndex )
    return false
    >
    /**
    * returns [numCols,numRows] of worksheet
    *
    * @param int $worksheetIndex
    *
    * @return array
    */
    public function dimension ( $ worksheetIndex = 0 ) <
    if ( ( $ ws = $ this -> worksheet ( $ worksheetIndex ) ) === false ) <
    return [ 0 , 0 ]
    >
    /* @var SimpleXMLElement $ws */
    $ ref = ( string ) $ ws -> dimension [ 'ref' ]
    if ( $ this -> _strpos ( $ ref , ':' ) !== false ) <
    $ d = explode ( ':' , $ ref )
    $ idx = $ this -> getIndex ( $ d [ 1 ] )
    return [ $ idx [ 0 ] + 1 , $ idx [ 1 ] + 1 ]
    >
    /*
    if ( $ref !== '' ) < // 0.6.8
    $index = $this->getIndex( $ref )
    return [ $index[0] + 1, $index[1] + 1 ]
    >
    */
    // slow method
    $ maxC = $ maxR = 0
    foreach ( $ ws -> sheetData -> row as $ row ) <
    foreach ( $ row -> c as $ c ) <
    $ idx = $ this -> getIndex ( ( string ) $ c [ 'r' ] )
    $ x = $ idx [ 0 ]
    $ y = $ idx [ 1 ]
    if ( $ x > 0 ) <
    if ( $ x > $ maxC ) <
    $ maxC = $ x
    >
    if ( $ y > $ maxR ) <
    $ maxR = $ y
    >
    >
    >
    >
    return [ $ maxC + 1 , $ maxR + 1 ]
    >
    public function getIndex ( $ cell = 'A1' ) <
    if ( preg_match ( '/([A-Z]+)(d+)/' , $ cell , $ m ) ) <
    $ col = $ m [ 1 ]
    $ row = $ m [ 2 ]
    $ colLen = $ this -> _strlen ( $ col )
    $ index = 0
    for ( $ i = $ colLen - 1 $ i >= 0 $ i -- ) <
    /** @noinspection PowerOperatorCanBeUsedInspection */
    $ index += ( ord ( $ col [ $ i ] ) - 64 ) * pow ( 26 , $ colLen - $ i - 1 )
    >
    return [ $ index - 1 , $ row - 1 ]
    >
    // $this->error( 'Invalid cell index ' . $cell )
    return [ - 1 , - 1 ]
    >
    public function value ( $ cell ) <
    // Determine data type
    $ dataType = ( string ) $ cell [ 't' ]
    if ( $ dataType === '' || $ dataType === 'n' ) < // number
    $ s = ( int ) $ cell [ 's' ]
    if ( $ s > 0 && isset ( $ this -> cellFormats [ $ s ] ) ) <
    if ( array_key_exists ( 'format' , $ this -> cellFormats [ $ s ])) <
    $ format = $ this -> cellFormats [ $ s ][ 'format' ]
    if ( preg_match ( '/[mM]/' , $ format ) ) < // [m]onth
    $ dataType = 'd'
    >
    >
    else <
    $ dataType = 's'
    >
    >
    >
    $ value = ''
    switch ( $ dataType ) <
    case 's' :
    // Value is a shared string
    if ( ( string ) $ cell -> v !== '' ) <
    $ value = $ this -> sharedstrings [ ( int ) $ cell -> v ]
    >
    break
    case 'b' :
    // Value is boolean
    $ value = ( string ) $ cell -> v
    if ( $ value === Ɔ' ) <
    $ value = false
    > elseif ( $ value === Ƈ' ) <
    $ value = true
    > else <
    $ value = ( bool ) $ cell -> v
    >
    break
    case 'inlineStr' :
    // Value is rich text inline
    $ value = $ this -> _parseRichText ( $ cell -> is )
    break
    case 'e' :
    // Value is an error message
    if ( ( string ) $ cell -> v !== '' ) <
    $ value = ( string ) $ cell -> v
    >
    break
    case 'd' :
    // Value is a date and non-empty
    if ( ! empty ( $ cell -> v ) ) <
    $ value = $ this -> datetimeFormat ? gmdate ( $ this -> datetimeFormat , $ this -> unixstamp ( ( float ) $ cell -> v ) ) : ( float ) $ cell -> v
    >
    break
    default :
    // Value is a string
    $ value = ( string ) $ cell -> v
    // Check for numeric values
    if ( is_numeric ( $ value ) && $ dataType !== 's' ) <
    /** @noinspection TypeUnsafeComparisonInspection */
    if ( $ value == ( int ) $ value ) <
    $ value = ( int ) $ value
    > /** @noinspection TypeUnsafeComparisonInspection */ elseif ( $ value == ( float ) $ value ) <
    $ value = ( float ) $ value
    >
    >
    >
    return $ value
    >
    public function unixstamp ( $ excelDateTime ) <
    $ d = floor ( $ excelDateTime ) // days since 1900 or 1904
    $ t = $ excelDateTime - $ d
    if ( $ this -> date1904 ) <
    $ d += 1462
    >
    $ t = ( abs ( $ d ) > 0 ) ? ( $ d - 25569 ) * 86400 + round ( $ t * 86400 ) : round ( $ t * 86400 )
    return ( int ) $ t
    >
    /**
    * Returns cell value
    * VERY SLOW! Use ->rows() or ->rowsEx()
    *
    * @param int $worksheetIndex
    * @param string|array $cell ref or coords, D12 or [3,12]
    *
    * @return mixed Returns NULL if not found
    */
    public function getCell ( $ worksheetIndex = 0 , $ cell = 'A1' ) <
    if ( ( $ ws = $ this -> worksheet ( $ worksheetIndex ) ) === false ) <
    return false
    >
    if ( is_array ( $ cell )) <
    $ cell = $ this -> _num2name ( $ cell [ 0 ]). $ cell [ 1 ] // [3,21] -> D21
    >
    if ( is_string ( $ cell ) ) <
    $ result = $ ws -> sheetData -> xpath ( "row/c[@r='" . $ cell . "']" )
    if ( count ( $ result ) ) <
    return $ this -> value ( $ result [ 0 ] )
    >
    >
    return null
    >
    public function href ( $ worksheetIndex , $ cell ) <
    $ ref = ( string ) $ cell [ 'r' ]
    return isset ( $ this -> hyperlinks [ $ worksheetIndex ][ $ ref ] ) ? $ this -> hyperlinks [ $ worksheetIndex ][ $ ref ] : ''
    >
    public function sheets () <
    return $ this -> sheets
    >
    public function sheetsCount () <
    return count ( $ this -> sheets )
    >
    public function sheetName ( $ worksheetIndex ) <
    if ( isset ( $ this -> sheetNames [ $ worksheetIndex ] ) ) <
    return $ this -> sheetNames [ $ worksheetIndex ]
    >
    return false
    >
    public function sheetNames () <
    return $ this -> sheetNames
    >
    // thx Gonzo
    public function getStyles () <
    return $ this -> styles
    >
    public function getPackage () <
    return $ this -> package
    >
    public function setDateTimeFormat ( $ value ) <
    $ this -> datetimeFormat = is_string ( $ value ) ? $ value : false
    >
    protected function _parseRichText ( $ is = null ) <
    $ value = []
    if ( isset ( $ is -> t ) ) <
    $ value [] = ( string ) $ is -> t
    > elseif ( isset ( $ is -> r ) ) <
    foreach ( $ is -> r as $ run ) <
    $ value [] = ( string ) $ run -> t
    >
    >
    return implode ( '' , $ value )
    >
    protected function _strlen ( $ str ) <
    return ( ini_get ( 'mbstring.func_overload' ) & 2 ) ? mb_strlen ( $ str , Ǝbit' ) : strlen ( $ str )
    >
    protected function _strpos ( $ haystack , $ needle , $ offset = 0 ) <
    return ( ini_get ( 'mbstring.func_overload' ) & 2 ) ? mb_strpos ( $ haystack , $ needle , $ offset , Ǝbit' ) : strpos ( $ haystack , $ needle , $ offset )
    >
    /*
    private function _strrpos( $haystack, $needle, $offset = 0 ) <
    return (ini_get('mbstring.func_overload') & 2) ? mb_strrpos( $haystack, $needle, $offset, Ǝbit') : strrpos($haystack, $needle, $offset)
    >*/
    protected function _strtoupper ( $ str ) <
    return ( ini_get ( 'mbstring.func_overload' ) & 2 ) ? mb_strtoupper ( $ str , Ǝbit' ) : strtoupper ( $ str )
    >
    protected function _substr ( $ str , $ start , $ length = null ) <
    return ( ini_get ( 'mbstring.func_overload' ) & 2 ) ? mb_substr ( $ str , $ start , ( $ length === null ) ? mb_strlen ( $ str , Ǝbit' ) : $ length , Ǝbit' ) : substr ( $ str , $ start , ( $ length === null ) ? strlen ( $ str ) : $ length )
    >
    protected function _getTarget ( $ base , $ target ) <
    $ target = trim ( $ target )
    if ( strpos ( $ target , '/' ) === 0 ) <
    return $ this -> _substr ( $ target , 1 )
    >
    $ target = ( $ base ? $ base . '/' : '' ) . $ target
    // a/b/../c -> a/c
    $ parts = explode ( '/' , $ target )
    $ abs = []
    foreach ( $ parts as $ p ) <
    if ( '.' === $ p ) <
    continue
    >
    if ( '..' === $ p ) <
    array_pop ( $ abs )
    > else <
    $ abs [] = $ p
    >
    >
    return implode ( '/' , $ abs )
    >
    protected function _num2name ( $ num ) <
    $ numeric = ( $ num - 1 ) % 26
    $ letter = chr ( 65 + $ numeric )
    $ num2 = ( int ) ( ( $ num - 1 ) / 26 )
    if ( $ num2 > 0 ) <
    return $ this -> _num2name ( $ num2 ) . $ letter
    >
    return $ letter
    >
    >

    You can’t perform that action at this time.

    You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.


    PICTURES FROM HISTORY: Rare Images Of War, History , WW2, Nazi Germany

    The 6th SS Mountain Division "Nord" was a German unit of the Waffen SS during World War II, formed in February 1941 as SS Kampfgruppe Nord (SS Battle Group North).The Division was the only Waffen SS unit to fight in the Arctic Circle when it was stationed in Finland and northern Russia between June and November 1941. It fought in Karelia until the Finnish armistice in September 1944 when it marched on foot 1,600 km through Finland and Norway. It arrived in Denmark in December and then transferred to western Germany. It fought in the Nordwind offensive in January 1945, where it suffered heavy losses and surrendered to the American forces in Austria at the end of the war.

    Soldiers from the 3rd Armored 'Totenkopf' SS Division fire anti-aircraft gun at enemy airplanes

    TOTENKOPF DIVISION

    SS and Italian soldiers share a smoke in the Balkans. 1943. The SS man has a 9mm MR 28 rifle slung around his shoulder

    Waffen SS soldiers pull a cart with arms

    HOW A WAFFEN SS SOLDIER WAS MADE




    SS men on the march. The soldier behind is a "Unterscharführer" SS. A rank in the SS equivalent to corporal or sergeant in other armies

    RELATIONSHIP BETWEEN THE WEHRMACHT AND WAFFEN SS

    An Officer and a rider from the SS prepare to transport a prisoner of the Red Army to headquarters for questioning. Interestingly, the number is either lost on the motorcycle, or specifically removed, in order not to give out the presence of the Waffen SS units in the area

    'A small band of the best and most determined is far more valuable than a large mass of camp followers.'
    Adolf Hitler in 1926

    'First, there is loyalty, God be praised, we have never had a single case of treason in our ranks.'

    'Every man who joins the SS must know, that at any moment, he may be mortally wounded.'
    Heinrich Himmler, speaking to SS generals at Poznan 4 October 1943

    'Men like Steiner and later Eicke . . . These were the people I most identified with and we often discussed how we could organize a soldierly force, an army along very different lines who would be superbly trained in a new way.'
    Sepp Dietrich post-war



    Tai tiesa. When the German soldiers entered the USSR in 1941, in many parts they were hailed as liberators and welcomed. In the image a Russian peasant woman gives the SS soldiers milk to drink.

    WAFFEN SS WERE NOT CRIMINALS: THEY WERE SOLDIERS

    Waffen SS men heavily camouflaged

    WHY WERE (ARE?) WAFFEN SS SOLDIERS THE BEST IN HISTORY?

    Soldiers of the 7th Mountain Division of the Waffen SS "Prinz Eugen" wave to a Luftwaffe plane flying above

    Normandy 1944. Soldiers of the 12th Armored Division of the Waffen SS "Hitler Youth" closely watch the sky, swarming with enemy aircraft.

    THE HITLERJUGEND WAFFEN SS DIVISION

    The SS soldiers are in a trench while their radio-man is trying to communicate

    A picture that would have had Stalin fuming. A Russian peasant woman offers to darn the sock of a Waffen SS soldier

    SS soldiers calculate and aim their mortar

    The men cross the river on a boat

    A SS soldier plays the piano after the fight. The men belong to the 1st SS Panzer Division "Leibstandarte Adolf Hitler". Kharkov, 1943

    Machine-gun crew from the 3rd Armored Division of the SS "Totenkopf"

    SS men fire away with a MG 42 machine gun

    A SS orderly gives a wounded soldier a drink of water

    This SS soldier darts to a forward position with a MG 42 machine gun

    Firing at the enemy with a MG 42 machine gun

    SS men about to fire a MG 34 machine gun

    Two Waffen SS soldiers

    Carrying the wounded comrades. Men of the 7th Volunteer Mountian 'Prinz Eugen' Division


    Part 1: MS PILSUDSKI and MS BATORY – Poland’s beautiful trans-Atlantic Liners!

    Poland’s Gdynia America Line (GAL), two 14,000-tons passenger ships, the BATORY, and PILSUDSKI were the pride of the fleet.

    They began their trans-Atlantic run from Europe to America in the mid-1930s. Built-in Cantieri Riuniti del’ Adriatico Shipyard, Triest-Monfalcone (Italy), the twin liners were 526 feet (160,3 m) long and could make 18 knots.

    The accommodation was for 796 in three classes (46 First Class, 370 Tourist -equivalent to 2nd Class, 400 Third Class, and crew of 350.)

    The new ships had materials and equipment that came from not less than a dozen countries. Affectionately they were dubbed the “International Ships.”

    The furnishing and interior decorations for the two liner’s interiors were designed and produced by Polish architects and artists.

    They emphasized the Polish character of the vessels, which were to act as links between the Polish immigrants in America and their native country.

    The ship’s interiors had a light, modern elegance, and were decorated with pieces by Jan Cybis – intriguing female figures carved into the silver mass alongside a 16th-century portrait of Stefan Batory. Refined down to the smallest detail with works by Zofia Stryjenska, aerial photographs show that it was decorated with Polish monuments. The ships were called floating art showrooms.

    The PILSUDSKI sailed for her first transatlantic voyage, Gdynia-New York, under the command of legendary captain Mamert Stankiewicz (“You mean the Captain” book) on Sep 15/ 1935. The trip was smooth, the weather was great, and the welcome in New York was enthusiastic. New York’s port-pilots admitted that even the M/S Normandie, which came to New York for the first time, a couple of months earlier, didn’t have such a wonderful welcome. The sister ship BATORY began sailing in 1936.

    Each round trip, Gdynia-New York-Gdynia took about three and a half weeks. During the whole of the pre-war period, each year, there were about ten round trips, with additional cruises to the Norwegian fiords in summer and Caribbean during the Christmas, New Year time. There was always an almost full complement of passengers on both ships.

    Both the BATORY and PILSUDSKI gained popularity amongst foreign passengers, thanks to the efforts of the officers and crew, management, service, and excellent Polish cuisine. The British often called BATORY, the little QUEEN ELIZABETH, because of some similarity of the silhouette.

    When WW II broke out, and Poland fell to the Germans in September 1939, the M/S PILSUDSKI and M/S BATORY with Polish crews were recruited by the British for military use. Two months later, PILSUDSKI was destroyed by German mines. M/S BATORY survived the war years (1939-45), is known as a “Lucky Ship” due to her wartime successes.


    M-1 (SS-47) - History

    Royal Navy Log Books of the World War 1 Era

    HMS GOLIATH &ndash January to April 1915, Indian Ocean, Mediterranean, Dardanelles

    Edited by Don Kindell, Naval History Researcher (Ohio)

    HMS Goliath (Maritime Quest, click images to enlarge)

    Pendant No. N.54 (1914). Launched 23.3.98 Chatham DY. 12,950 tons, 421(oa), 390(pp)x74x26ft. TE 13500ihp, 18kts. Armament: 4-12in, 12-6in, 12-12pdr, 4-18in tt. Armour: 6in sides, 2.5in deck, 9in guns. 7th or 9th BS, Channel Fleet at outbreak of war, then abroad. Battle Honour (and link to despatches, casualties, awards) Dardanelles 1915. Torpedoed 13.5.15 by Turkish TB MAUVENET off Cape Helles. (British Warships 1914-1919)

    Joined the Channel Fleet in 1906, but reduced to nucleus crew in March 1907 after being fitted with fire control. Machinery overhauled August 1907-February 1908 and then went to Malta (en route one of her propeller shafts fractured, necessitating a 4-month repair). Joined 4th Fleet at Nore in April 1909, and then 3rd Fleet in 1913-14. Commissioned in the 8th Battle Squadron for service in the Channel in August 1914 and then went to Loch Ewe as guardship. Covered landing of marines at Ostend and in September 1914 went to East Indies. In November 1914 took part in Rufiji River operations against the Konigsberg, and then went to the Dardanelles in April 1915. Provided gunfire support at Cape Helles and was damaged on 25 April and 2 May. On the night of 13 May she was torpedoed by the Turkish torpedo-boat Muavenet and sank quickly with the loss of 570 men. (Battle honour - Dardanelles 1915). (Conway's All the World's Fighting Ships 1860-1905 and 1906-21)

    British Isles Bases - Selected Charts

    British Naval Bases Worldwide - Selected Charts

    1. Latitude/longitude, including for days in port, show representative decimal positions for each day, as calculated by the Old Weather project's analysis program. As such, they differ by varying amounts from the positions recorded, usually at noon, in the log pages. In addition, some latitudes/longitudes have been amended in edited logs for errors in the logs, for errors in identifying locations by the analysis program, or simply for greater accuracy. In all cases, refer to the log-page scans for the positions as originally recorded. Not all log pages contain this information and the ships' positions have therefore often been estimated.

    2. Full account of any day is available by clicking on the link above that day. Groups of links refer to log book covers and introductory information some may be blank.

    THE VOYAGES OF HMS GOLIATH 1914

    (Maps prepared using Journey Plotter, developed by Maikel. The Plots can only be approximate. They are made by joining-up positions on successive days, and sometimes positions are not given. There will therefore be occasions when the ship appears to have travelled overland)


    Žiūrėti video įrašą: Daejoyoung 20070325 #001 (Gegužė 2022).