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