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