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