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