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