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