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