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