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