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