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