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