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