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