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