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