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