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