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