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