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