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