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