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