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