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