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