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