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