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