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